Merge remote-tracking branch 'origin/main' into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/cmake/CMakeLists.txt
#	indra/cmake/GoogleMock.cmake
#	indra/llaudio/llaudioengine_fmodstudio.cpp
#	indra/llaudio/llaudioengine_fmodstudio.h
#	indra/llaudio/lllistener_fmodstudio.cpp
#	indra/llaudio/lllistener_fmodstudio.h
#	indra/llaudio/llstreamingaudio_fmodstudio.cpp
#	indra/llaudio/llstreamingaudio_fmodstudio.h
#	indra/llcharacter/llmultigesture.cpp
#	indra/llcharacter/llmultigesture.h
#	indra/llimage/llimage.cpp
#	indra/llimage/llimagepng.cpp
#	indra/llimage/llimageworker.cpp
#	indra/llimage/tests/llimageworker_test.cpp
#	indra/llmessage/tests/llmockhttpclient.h
#	indra/llprimitive/llgltfmaterial.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llui/llcombobox.cpp
#	indra/llui/llfolderview.cpp
#	indra/llui/llfolderviewmodel.h
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltextvalidate.cpp
#	indra/llui/lltextvalidate.h
#	indra/llui/lluictrl.h
#	indra/llui/llview.cpp
#	indra/llwindow/llwindowmacosx.cpp
#	indra/newview/app_settings/settings.xml
#	indra/newview/llappearancemgr.cpp
#	indra/newview/llappearancemgr.h
#	indra/newview/llavatarpropertiesprocessor.cpp
#	indra/newview/llavatarpropertiesprocessor.h
#	indra/newview/llbreadcrumbview.cpp
#	indra/newview/llbreadcrumbview.h
#	indra/newview/llbreastmotion.cpp
#	indra/newview/llbreastmotion.h
#	indra/newview/llconversationmodel.h
#	indra/newview/lldensityctrl.cpp
#	indra/newview/lldensityctrl.h
#	indra/newview/llface.inl
#	indra/newview/llfloatereditsky.cpp
#	indra/newview/llfloatereditwater.cpp
#	indra/newview/llfloateremojipicker.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterprofiletexture.cpp
#	indra/newview/llfloaterprofiletexture.h
#	indra/newview/llgesturemgr.cpp
#	indra/newview/llgesturemgr.h
#	indra/newview/llimpanel.cpp
#	indra/newview/llimpanel.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llinventorybridge.h
#	indra/newview/llinventoryclipboard.cpp
#	indra/newview/llinventoryclipboard.h
#	indra/newview/llinventoryfunctions.cpp
#	indra/newview/llinventoryfunctions.h
#	indra/newview/llinventorygallery.cpp
#	indra/newview/lllistbrowser.cpp
#	indra/newview/lllistbrowser.h
#	indra/newview/llpanelobjectinventory.cpp
#	indra/newview/llpanelprofile.cpp
#	indra/newview/llpanelprofile.h
#	indra/newview/llpreviewgesture.cpp
#	indra/newview/llsavedsettingsglue.cpp
#	indra/newview/llsavedsettingsglue.h
#	indra/newview/lltooldraganddrop.cpp
#	indra/newview/llurllineeditorctrl.cpp
#	indra/newview/llvectorperfoptions.cpp
#	indra/newview/llvectorperfoptions.h
#	indra/newview/llviewerparceloverlay.cpp
#	indra/newview/llviewertexlayer.cpp
#	indra/newview/llviewertexturelist.cpp
#	indra/newview/macmain.h
#	indra/test/test.cpp

1 files changed, 255 insertions, 255 deletions

diff --git a/indra/newview/lltexturecache.h b/indra/newview/lltexturecache.h
index 3947cb850f..5ac0a0428d 100644
--- a/indra/newview/lltexturecache.h
+++ b/indra/newview/lltexturecache.h
@@ -1,255 +1,255 @@
-/** 
- * @file lltexturecache.h
- * @brief Object for managing texture cachees.
- *
- * $LicenseInfo:firstyear=2000&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLTEXTURECACHE_H
-#define LL_LLTEXTURECACHE_H
-
-#include "lldir.h"
-#include "llstl.h"
-#include "llstring.h"
-#include "lluuid.h"
-
-#include "llworkerthread.h"
-
-class LLImageFormatted;
-class LLTextureCacheWorker;
-class LLImageRaw;
-
-class LLTextureCache : public LLWorkerThread
-{
-	friend class LLTextureCacheWorker;
-	friend class LLTextureCacheRemoteWorker;
-	friend class LLTextureCacheLocalFileWorker;
-
-private:
-
-#if LL_WINDOWS
-#pragma pack(push,1)
-#endif
-
-	// Entries
-	static const U32 sHeaderEncoderStringSize = 32;
-	struct EntriesInfo
-	{
-		EntriesInfo() : mVersion(0.f), mAdressSize(0), mEntries(0) { memset(mEncoderVersion, 0, sHeaderEncoderStringSize); }
-		F32 mVersion;
-		U32 mAdressSize;
-		char mEncoderVersion[sHeaderEncoderStringSize];
-		U32 mEntries;
-	};
-	struct Entry
-	{
-        	Entry() :
-		        mBodySize(0),
-			mImageSize(0),
-			mTime(0)
-		{
-		}
-		Entry(const LLUUID& id, S32 imagesize, S32 bodysize, U32 time) :
-			mID(id), mImageSize(imagesize), mBodySize(bodysize), mTime(time) {}
-		void init(const LLUUID& id, U32 time) { mID = id, mImageSize = 0; mBodySize = 0; mTime = time; }
-		Entry& operator=(const Entry& entry) {mID = entry.mID, mImageSize = entry.mImageSize; mBodySize = entry.mBodySize; mTime = entry.mTime; return *this;}
-		LLUUID mID; // 16 bytes
-		S32 mImageSize; // total size of image if known
-		S32 mBodySize; // size of body file in body cache
-		U32 mTime; // seconds since 1/1/1970
-	};
-
-#if LL_WINDOWS
-#pragma pack(pop)
-#endif
-
-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*/ size_t update(F32 max_time_ms);
-	
-	void purgeCache(ELLPath location, bool remove_dir = true);
-	void setReadOnly(bool read_only) ;
-	S64 initCache(ELLPath location, S64 maxsize, bool texture_cache_mismatch);
-
-	handle_t readFromCache(const std::string& local_filename, const LLUUID& id, S32 offset, S32 size,
-						   ReadResponder* responder);
-
-	handle_t readFromCache(const LLUUID& id, S32 offset, S32 size,
-						   ReadResponder* responder);
-	bool readComplete(handle_t handle, bool abort);
-	handle_t writeToCache(const LLUUID& id, const U8* data, S32 datasize, S32 imagesize, LLPointer<LLImageRaw> rawimage, S32 discardlevel,
-						  WriteResponder* responder);
-	LLPointer<LLImageRaw> readFromFastCache(const LLUUID& id, S32& discardlevel);
-	bool writeComplete(handle_t handle, bool abort = false);
-	void prioritizeWrite(handle_t handle);
-
-	bool 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(); }
-	S64Bytes getUsage() { return S64Bytes(mTexturesSizeTotal); }
-	S64Bytes getMaxUsage() { return S64Bytes(sCacheMaxTexturesSize); }
-	U32 getEntries() { return mHeaderEntriesInfo.mEntries; }
-	U32 getMaxEntries() { return sCacheMaxEntries; };
-	bool isInCache(const LLUUID& id) ;
-	bool isInLocal(const LLUUID& id) ; //not thread safe at the moment
-
-protected:
-	// Accessed by LLTextureCacheWorker
-	std::string getLocalFileName(const LLUUID& id);
-	std::string getTextureFileName(const LLUUID& id);
-	void addCompleted(Responder* responder, bool success);
-	
-protected:
-	//void setFileAPRPool(apr_pool_t* pool) { mFileAPRPool = pool ; }
-
-private:
-	void setDirNames(ELLPath location);
-	void readHeaderCache();
-	void clearCorruptedCache();
-	void purgeAllTextures(bool purge_directories);
-	void purgeTexturesLazy(F32 time_limit_sec);
-	void purgeTextures(bool validate);
-	LLAPRFile* openHeaderEntriesFile(bool readonly, S32 offset);
-	void closeHeaderEntriesFile();
-	void readEntriesHeader();
-	void setEntriesHeader();
-	void writeEntriesHeader();
-	S32 openAndReadEntry(const LLUUID& id, Entry& entry, bool create);
-	bool updateEntry(S32& idx, Entry& entry, S32 new_image_size, S32 new_body_size);
-	void updateEntryTimeStamp(S32 idx, Entry& entry) ;
-	U32 openAndReadEntries(std::vector<Entry>& entries);
-	void writeEntriesAndClose(const std::vector<Entry>& entries);
-	void readEntryFromHeaderImmediately(S32& idx, Entry& entry) ;
-	void writeEntryToHeaderImmediately(S32& idx, Entry& entry, bool write_header = false) ;
-	void removeEntry(S32 idx, Entry& entry, std::string& filename);
-	void removeCachedTexture(const LLUUID& id) ;
-	S32 getHeaderCacheEntry(const LLUUID& id, Entry& entry);
-	S32 setHeaderCacheEntry(const LLUUID& id, Entry& entry, S32 imagesize, S32 datasize);
-	void writeUpdatedEntries() ;
-	void updatedHeaderEntriesFile() ;
-	void lockHeaders() { mHeaderMutex.lock(); }
-	void unlockHeaders() { mHeaderMutex.unlock(); }
-	
-	void openFastCache(bool first_time = false);
-	void closeFastCache(bool forced = false);
-	bool writeToFastCache(LLUUID image_id, S32 cache_id, LLPointer<LLImageRaw> raw, S32 discardlevel);	
-
-private:
-	// Internal
-	LLMutex mWorkersMutex;
-	LLMutex mHeaderMutex;
-	LLMutex mListMutex;
-	LLMutex mFastCacheMutex;
-	LLAPRFile* mHeaderAPRFile;
-	LLVolatileAPRPool* mFastCachePoolp;
-
-	// mLocalAPRFilePoolp is not thread safe and is meant only for workers
-	// howhever mHeaderEntriesFileName is accessed not from workers' threads
-	// so it needs own pool (not thread safe by itself, relies onto header's mutex)
-	LLVolatileAPRPool*   mHeaderAPRFilePoolp;
-	
-	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;
-	
-	// HEADERS (Include first mip)
-	std::string mHeaderEntriesFileName;
-	std::string mHeaderDataFileName;
-	std::string mFastCacheFileName;
-	EntriesInfo mHeaderEntriesInfo;
-	std::set<S32> mFreeList; // deleted entries
-	std::set<LLUUID> mLRU;
-	typedef std::map<LLUUID, S32> id_map_t;
-	id_map_t mHeaderIDMap;
-
-	LLAPRFile*   mFastCachep;
-	LLFrameTimer mFastCacheTimer;
-	U8*          mFastCachePadBuffer;
-
-	// BODIES (TEXTURES minus headers)
-	std::string mTexturesDirName;
-	typedef std::map<LLUUID,S32> size_map_t;
-	size_map_t mTexturesSizeMap;
-	S64 mTexturesSizeTotal;
-	LLAtomicBool mDoPurge;
-
-	typedef std::map<S32, Entry> idx_entry_map_t;
-	idx_entry_map_t mUpdatedEntryMap;
-	typedef std::vector<std::pair<S32, Entry> > idx_entry_vector_t;
-	idx_entry_vector_t mPurgeEntryList;
-
-	// Statics
-	static F32 sHeaderCacheVersion;
-	static U32 sHeaderCacheAddressSize;
-	static std::string sHeaderCacheEncoderVersion;
-	static U32 sCacheMaxEntries;
-	static S64 sCacheMaxTexturesSize;
-};
-
-extern const S32 TEXTURE_CACHE_ENTRY_SIZE;
-
-#endif // LL_LLTEXTURECACHE_H
+/**

+ * @file lltexturecache.h

+ * @brief Object for managing texture cachees.

+ *

+ * $LicenseInfo:firstyear=2000&license=viewerlgpl$

+ * Second Life Viewer Source Code

+ * Copyright (C) 2010, Linden Research, Inc.

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation;

+ * version 2.1 of the License only.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

+ *

+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

+ * $/LicenseInfo$

+ */

+

+#ifndef LL_LLTEXTURECACHE_H

+#define LL_LLTEXTURECACHE_H

+

+#include "lldir.h"

+#include "llstl.h"

+#include "llstring.h"

+#include "lluuid.h"

+

+#include "llworkerthread.h"

+

+class LLImageFormatted;

+class LLTextureCacheWorker;

+class LLImageRaw;

+

+class LLTextureCache : public LLWorkerThread

+{

+    friend class LLTextureCacheWorker;

+    friend class LLTextureCacheRemoteWorker;

+    friend class LLTextureCacheLocalFileWorker;

+

+private:

+

+#if LL_WINDOWS

+#pragma pack(push,1)

+#endif

+

+    // Entries

+    static const U32 sHeaderEncoderStringSize = 32;

+    struct EntriesInfo

+    {

+        EntriesInfo() : mVersion(0.f), mAdressSize(0), mEntries(0) { memset(mEncoderVersion, 0, sHeaderEncoderStringSize); }

+        F32 mVersion;

+        U32 mAdressSize;

+        char mEncoderVersion[sHeaderEncoderStringSize];

+        U32 mEntries;

+    };

+    struct Entry

+    {

+            Entry() :

+                mBodySize(0),

+            mImageSize(0),

+            mTime(0)

+        {

+        }

+        Entry(const LLUUID& id, S32 imagesize, S32 bodysize, U32 time) :

+            mID(id), mImageSize(imagesize), mBodySize(bodysize), mTime(time) {}

+        void init(const LLUUID& id, U32 time) { mID = id, mImageSize = 0; mBodySize = 0; mTime = time; }

+        Entry& operator=(const Entry& entry) {mID = entry.mID, mImageSize = entry.mImageSize; mBodySize = entry.mBodySize; mTime = entry.mTime; return *this;}

+        LLUUID mID; // 16 bytes

+        S32 mImageSize; // total size of image if known

+        S32 mBodySize; // size of body file in body cache

+        U32 mTime; // seconds since 1/1/1970

+    };

+

+#if LL_WINDOWS

+#pragma pack(pop)

+#endif

+

+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*/ size_t update(F32 max_time_ms);

+

+    void purgeCache(ELLPath location, bool remove_dir = true);

+    void setReadOnly(bool read_only) ;

+    S64 initCache(ELLPath location, S64 maxsize, bool texture_cache_mismatch);

+

+    handle_t readFromCache(const std::string& local_filename, const LLUUID& id, S32 offset, S32 size,

+                           ReadResponder* responder);

+

+    handle_t readFromCache(const LLUUID& id, S32 offset, S32 size,

+                           ReadResponder* responder);

+    bool readComplete(handle_t handle, bool abort);

+    handle_t writeToCache(const LLUUID& id, const U8* data, S32 datasize, S32 imagesize, LLPointer<LLImageRaw> rawimage, S32 discardlevel,

+                          WriteResponder* responder);

+    LLPointer<LLImageRaw> readFromFastCache(const LLUUID& id, S32& discardlevel);

+    bool writeComplete(handle_t handle, bool abort = false);

+    void prioritizeWrite(handle_t handle);

+

+    bool 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(); }

+    S64Bytes getUsage() { return S64Bytes(mTexturesSizeTotal); }

+    S64Bytes getMaxUsage() { return S64Bytes(sCacheMaxTexturesSize); }

+    U32 getEntries() { return mHeaderEntriesInfo.mEntries; }

+    U32 getMaxEntries() { return sCacheMaxEntries; };

+    bool isInCache(const LLUUID& id) ;

+    bool isInLocal(const LLUUID& id) ; //not thread safe at the moment

+

+protected:

+    // Accessed by LLTextureCacheWorker

+    std::string getLocalFileName(const LLUUID& id);

+    std::string getTextureFileName(const LLUUID& id);

+    void addCompleted(Responder* responder, bool success);

+

+protected:

+    //void setFileAPRPool(apr_pool_t* pool) { mFileAPRPool = pool ; }

+

+private:

+    void setDirNames(ELLPath location);

+    void readHeaderCache();

+    void clearCorruptedCache();

+    void purgeAllTextures(bool purge_directories);

+    void purgeTexturesLazy(F32 time_limit_sec);

+    void purgeTextures(bool validate);

+    LLAPRFile* openHeaderEntriesFile(bool readonly, S32 offset);

+    void closeHeaderEntriesFile();

+    void readEntriesHeader();

+    void setEntriesHeader();

+    void writeEntriesHeader();

+    S32 openAndReadEntry(const LLUUID& id, Entry& entry, bool create);

+    bool updateEntry(S32& idx, Entry& entry, S32 new_image_size, S32 new_body_size);

+    void updateEntryTimeStamp(S32 idx, Entry& entry) ;

+    U32 openAndReadEntries(std::vector<Entry>& entries);

+    void writeEntriesAndClose(const std::vector<Entry>& entries);

+    void readEntryFromHeaderImmediately(S32& idx, Entry& entry) ;

+    void writeEntryToHeaderImmediately(S32& idx, Entry& entry, bool write_header = false) ;

+    void removeEntry(S32 idx, Entry& entry, std::string& filename);

+    void removeCachedTexture(const LLUUID& id) ;

+    S32 getHeaderCacheEntry(const LLUUID& id, Entry& entry);

+    S32 setHeaderCacheEntry(const LLUUID& id, Entry& entry, S32 imagesize, S32 datasize);

+    void writeUpdatedEntries() ;

+    void updatedHeaderEntriesFile() ;

+    void lockHeaders() { mHeaderMutex.lock(); }

+    void unlockHeaders() { mHeaderMutex.unlock(); }

+

+    void openFastCache(bool first_time = false);

+    void closeFastCache(bool forced = false);

+    bool writeToFastCache(LLUUID image_id, S32 cache_id, LLPointer<LLImageRaw> raw, S32 discardlevel);

+

+private:

+    // Internal

+    LLMutex mWorkersMutex;

+    LLMutex mHeaderMutex;

+    LLMutex mListMutex;

+    LLMutex mFastCacheMutex;

+    LLAPRFile* mHeaderAPRFile;

+    LLVolatileAPRPool* mFastCachePoolp;

+

+    // mLocalAPRFilePoolp is not thread safe and is meant only for workers

+    // howhever mHeaderEntriesFileName is accessed not from workers' threads

+    // so it needs own pool (not thread safe by itself, relies onto header's mutex)

+    LLVolatileAPRPool*   mHeaderAPRFilePoolp;

+

+    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;

+

+    // HEADERS (Include first mip)

+    std::string mHeaderEntriesFileName;

+    std::string mHeaderDataFileName;

+    std::string mFastCacheFileName;

+    EntriesInfo mHeaderEntriesInfo;

+    std::set<S32> mFreeList; // deleted entries

+    std::set<LLUUID> mLRU;

+    typedef std::map<LLUUID, S32> id_map_t;

+    id_map_t mHeaderIDMap;

+

+    LLAPRFile*   mFastCachep;

+    LLFrameTimer mFastCacheTimer;

+    U8*          mFastCachePadBuffer;

+

+    // BODIES (TEXTURES minus headers)

+    std::string mTexturesDirName;

+    typedef std::map<LLUUID,S32> size_map_t;

+    size_map_t mTexturesSizeMap;

+    S64 mTexturesSizeTotal;

+    LLAtomicBool mDoPurge;

+

+    typedef std::map<S32, Entry> idx_entry_map_t;

+    idx_entry_map_t mUpdatedEntryMap;

+    typedef std::vector<std::pair<S32, Entry> > idx_entry_vector_t;

+    idx_entry_vector_t mPurgeEntryList;

+

+    // Statics

+    static F32 sHeaderCacheVersion;

+    static U32 sHeaderCacheAddressSize;

+    static std::string sHeaderCacheEncoderVersion;

+    static U32 sCacheMaxEntries;

+    static S64 sCacheMaxTexturesSize;

+};

+

+extern const S32 TEXTURE_CACHE_ENTRY_SIZE;

+

+#endif // LL_LLTEXTURECACHE_H