88 files changed, 3836 insertions, 1838 deletions
diff --git a/linden/indra/llimage/llimage.cpp b/linden/indra/llimage/llimage.cpp
index 4b0076e..32891e7 100644
--- a/linden/indra/llimage/llimage.cpp
+++ b/linden/indra/llimage/llimage.cpp
@@ -55,13 +55,9 @@ std::string LLImage::sLastErrorMessage;
 LLMutex* LLImage::sMutex = NULL;
 //static
-void LLImage::initClass(LLWorkerThread* workerthread)
+void LLImage::initClass()
 {
        sMutex = new LLMutex(NULL);
-        if (workerthread)
-        {
-                LLImageWorker::initImageWorker(workerthread);
-        }
        LLImageJ2C::openDSO();
 }
@@ -69,7 +65,6 @@ void LLImage::initClass(LLWorkerThread* workerthread)
 void LLImage::cleanupClass()
 {
        LLImageJ2C::closeDSO();
-        LLImageWorker::cleanupImageWorker();
        delete sMutex;
        sMutex = NULL;
 }
@@ -1242,25 +1237,28 @@ bool LLImageRaw::createFromFile(const std::string &filename, bool j2c_lowest_mip
        ifs.read ((char*)buffer, length);       /* Flawfinder: ignore */
        ifs.close();
        
-        image->updateData();
+        BOOL success;
-        
-        if (j2c_lowest_mip_only && codec == IMG_CODEC_J2C)
+        success = image->updateData();
+        if (success)
        {
-                S32 width = image->getWidth();
+                if (j2c_lowest_mip_only && codec == IMG_CODEC_J2C)
-                S32 height = image->getHeight();
-                S32 discard_level = 0;
-                while (width > 1 && height > 1 && discard_level < MAX_DISCARD_LEVEL)
                {
-                        width >>= 1;
+                        S32 width = image->getWidth();
-                        height >>= 1;
+                        S32 height = image->getHeight();
-                        discard_level++;
+                        S32 discard_level = 0;
+                        while (width > 1 && height > 1 && discard_level < MAX_DISCARD_LEVEL)
+                        {
+                                width >>= 1;
+                                height >>= 1;
+                                discard_level++;
+                        }
+                        ((LLImageJ2C *)((LLImageFormatted*)image))->setDiscardLevel(discard_level);
                }
-                ((LLImageJ2C *)((LLImageFormatted*)image))->setDiscardLevel(discard_level);
+                success = image->decode(this, 100000.0f);
        }
-        
-        BOOL success = image->decode(this, 100000.0f);
-        image = NULL; // deletes image
+        image = NULL; // deletes image
        if (!success)
        {
                deleteData();
diff --git a/linden/indra/llimage/llimage.h b/linden/indra/llimage/llimage.h
index bd609b6..be2eb08 100644
--- a/linden/indra/llimage/llimage.h
+++ b/linden/indra/llimage/llimage.h
@@ -49,7 +49,8 @@ const S32 MAX_IMAGE_AREA = MAX_IMAGE_SIZE * MAX_IMAGE_SIZE;
 const S32 MAX_IMAGE_COMPONENTS = 8;
 const S32 MAX_IMAGE_DATA_SIZE = MAX_IMAGE_AREA * MAX_IMAGE_COMPONENTS;
-// Note!  These CANNOT be changed without invalidating the viewer VFS files, I think?
+// Note!  These CANNOT be changed without modifying simulator code
+// *TODO: change both to 1024 when SIM texture fetching is deprecated
 const S32 FIRST_PACKET_SIZE = 600;
 const S32 MAX_IMG_PACKET_SIZE = 1000;
@@ -60,7 +61,6 @@ const S32 MAX_IMG_PACKET_SIZE = 1000;
 class LLImageFormatted;
 class LLImageRaw;
 class LLColor4U;
-class LLWorkerThread;
 typedef enum e_image_codec
 {
@@ -81,7 +81,7 @@ typedef enum e_image_codec
 class LLImage
 {
 public:
-        static void initClass(LLWorkerThread* workerthread);
+        static void initClass();
        static void cleanupClass();
        static const std::string& getLastError();
@@ -309,7 +309,7 @@ protected:
 protected:
        S8 mCodec;
        S8 mDecoding;
-        S8 mDecoded;
+        S8 mDecoded;  // unused, but changing LLImage layout requires recompiling static Mac/Linux libs. 2009-01-30 JC
        S8 mDiscardLevel;
        
 public:
diff --git a/linden/indra/llimage/llimagedxt.cpp b/linden/indra/llimage/llimagedxt.cpp
index 1ce4517..0aa6840 100644
--- a/linden/indra/llimage/llimagedxt.cpp
+++ b/linden/indra/llimage/llimagedxt.cpp
@@ -264,6 +264,8 @@ void LLImageDXT::setFormat()
 // virtual
 BOOL LLImageDXT::decode(LLImageRaw* raw_image, F32 time)
 {
+        // *TODO: Test! This has been tweaked since its intial inception,
+        //  but we don't use it any more!
        llassert_always(raw_image);
        
        if (mFileFormat >= FORMAT_DXT1 && mFileFormat <= FORMAT_DXR5)
@@ -274,8 +276,17 @@ BOOL LLImageDXT::decode(LLImageRaw* raw_image, F32 time)
        
        S32 width = getWidth(), height = getHeight();
        S32 ncomponents = getComponents();
+        U8* data = NULL;
+        if (mDiscardLevel >= 0)
+        {
+                data = getData() + getMipOffset(mDiscardLevel);
+                calcDiscardWidthHeight(mDiscardLevel, mFileFormat, width, height);
+        }
+        else
+        {
+                data = getData() + getMipOffset(0);
+        }
        S32 image_size = formatBytes(mFileFormat, width, height);
-        U8* data = getData() + getMipOffset(0);
        
        if ((!getData()) || (data + image_size > getData() + getDataSize()))
        {
@@ -300,10 +311,8 @@ BOOL LLImageDXT::getMipData(LLPointer<LLImageRaw>& raw, S32 discard)
                llerrs << "Request for invalid discard level" << llendl;
        }
        U8* data = getData() + getMipOffset(discard);
-        // I'm not sure these are the correct initial values for height and width,
+        S32 width = 0;
-        // but previously they were being used uninitialized. JC
+        S32 height = 0;
-        S32 width = raw->getWidth();
-        S32 height = raw->getHeight();
        calcDiscardWidthHeight(discard, mFileFormat, width, height);
        raw = new LLImageRaw(data, width, height, getComponents());
        return TRUE;
diff --git a/linden/indra/llimage/llimagej2c.cpp b/linden/indra/llimage/llimagej2c.cpp
index ed58f85..1aae83e 100644
--- a/linden/indra/llimage/llimagej2c.cpp
+++ b/linden/indra/llimage/llimagej2c.cpp
@@ -277,6 +277,7 @@ BOOL LLImageJ2C::decode(LLImageRaw *raw_imagep, F32 decode_time)
 }
+// Returns TRUE to mean done, whether successful or not.
 BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 first_channel, S32 max_channel_count )
 {
        LLMemType mt1((LLMemType::EMemType)mMemType);
@@ -289,7 +290,7 @@ BOOL LLImageJ2C::decodeChannels(LLImageRaw *raw_imagep, F32 decode_time, S32 fir
        if (!getData() || (getDataSize() < 16))
        {
                setLastError("LLImageJ2C uninitialized");
-                res = FALSE;
+                res = TRUE; // done
        }
        else
        {
@@ -342,7 +343,7 @@ BOOL LLImageJ2C::encode(const LLImageRaw *raw_imagep, const char* comment_text,
 //static
 S32 LLImageJ2C::calcHeaderSizeJ2C()
 {
-        return 600; //2048; // ??? hack... just needs to be >= actual header size...
+        return FIRST_PACKET_SIZE; // Hack. just needs to be >= actual header size...
 }
 //static
diff --git a/linden/indra/llimage/llimagejpeg.cpp b/linden/indra/llimage/llimagejpeg.cpp
index fa0dd3f..79ea79c 100644
--- a/linden/indra/llimage/llimagejpeg.cpp
+++ b/linden/indra/llimage/llimagejpeg.cpp
@@ -188,6 +188,7 @@ void LLImageJPEG::decodeTermSource (j_decompress_ptr cinfo)
 }
+// Returns true when done, whether or not decode was successful.
 BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
 {
        llassert_always(raw_image);
@@ -198,7 +199,7 @@ BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
        if (!getData() || (0 == getDataSize()))
        {
                setLastError("LLImageJPEG trying to decode an image with no data!");
-                return FALSE;
+                return TRUE;  // done
        }
        
        S32 row_stride = 0;
@@ -226,7 +227,7 @@ BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
        if(setjmp(sSetjmpBuffer))
        {
                jpeg_destroy_decompress(&cinfo);
-                return FALSE;
+                return TRUE; // done
        }
        try
        {
@@ -320,7 +321,7 @@ BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
        catch (int)
        {
                jpeg_destroy_decompress(&cinfo);
-                return FALSE;
+                return TRUE; // done
        }
        // Check to see whether any corrupt-data warnings occurred
@@ -328,7 +329,7 @@ BOOL LLImageJPEG::decode(LLImageRaw* raw_image, F32 decode_time)
        {
                // TODO: extract the warning to find out what went wrong.
                setLastError( "Unable to decode JPEG image.");
-                return FALSE;
+                return TRUE; // done
        }
        return TRUE;
diff --git a/linden/indra/llimage/llimageworker.cpp b/linden/indra/llimage/llimageworker.cpp
index 532e996..86d4151 100644
--- a/linden/indra/llimage/llimageworker.cpp
+++ b/linden/indra/llimage/llimageworker.cpp
@@ -37,152 +37,138 @@
 //----------------------------------------------------------------------------
-//static
+// MAIN THREAD
-LLWorkerThread* LLImageWorker::sWorkerThread = NULL;
+LLImageDecodeThread::LLImageDecodeThread(bool threaded)
-S32 LLImageWorker::sCount = 0;
+        : LLQueuedThread("imagedecode", threaded)
+{
+        mCreationMutex = new LLMutex(getAPRPool());
+}
-//static
+// MAIN THREAD
-void LLImageWorker::initImageWorker(LLWorkerThread* workerthread)
+// virtual
+S32 LLImageDecodeThread::update(U32 max_time_ms)
 {
-        sWorkerThread = workerthread;
+        LLMutexLock lock(mCreationMutex);
+        for (creation_list_t::iterator iter = mCreationList.begin();
+                 iter != mCreationList.end(); ++iter)
+        {
+                creation_info& info = *iter;
+                ImageRequest* req = new ImageRequest(info.handle, info.image,
+                                                                                         info.priority, info.discard, info.needs_aux,
+                                                                                         info.responder);
+                addRequest(req);
+        }
+        mCreationList.clear();
+        S32 res = LLQueuedThread::update(max_time_ms);
+        return res;
 }
-//static
+LLImageDecodeThread::handle_t LLImageDecodeThread::decodeImage(LLImageFormatted* image, 
-void LLImageWorker::cleanupImageWorker()
+        U32 priority, S32 discard, BOOL needs_aux, Responder* responder)
+{
+        LLMutexLock lock(mCreationMutex);
+        handle_t handle = generateHandle();
+        mCreationList.push_back(creation_info(handle, image, priority, discard, needs_aux, responder));
+        return handle;
+}
+// Used by unit test only
+// Returns the size of the mutex guarded list as an indication of sanity
+S32 LLImageDecodeThread::tut_size()
+{
+        LLMutexLock lock(mCreationMutex);
+        S32 res = mCreationList.size();
+        return res;
+}
+LLImageDecodeThread::Responder::~Responder()
 {
 }
 //----------------------------------------------------------------------------
-LLImageWorker::LLImageWorker(LLImageFormatted* image, U32 priority,
+LLImageDecodeThread::ImageRequest::ImageRequest(handle_t handle, LLImageFormatted* image, 
-                                                         S32 discard,
+                                                                                                U32 priority, S32 discard, BOOL needs_aux,
-                                                         LLPointer<LLResponder> responder)
+                                                                                                LLImageDecodeThread::Responder* responder)
-        : LLWorkerClass(sWorkerThread, "Image"),
+        : LLQueuedThread::QueuedRequest(handle, priority, FLAG_AUTO_COMPLETE),
          mFormattedImage(image),
-          mDecodedType(-1),
          mDiscardLevel(discard),
-          mPriority(priority),
+          mNeedsAux(needs_aux),
+          mDecodedRaw(FALSE),
+          mDecodedAux(FALSE),
          mResponder(responder)
 {
-        ++sCount;
 }
-LLImageWorker::~LLImageWorker()
+LLImageDecodeThread::ImageRequest::~ImageRequest()
 {
-        mDecodedImage = NULL;
+        mDecodedImageRaw = NULL;
+        mDecodedImageAux = NULL;
        mFormattedImage = NULL;
-        --sCount;
 }
 //----------------------------------------------------------------------------
-//virtual, main thread
-void LLImageWorker::startWork(S32 param)
-{
-        llassert_always(mDecodedImage.isNull());
-        mDecodedType = -1;
-}
-bool LLImageWorker::doWork(S32 param)
+// Returns true when done, whether or not decode was successful.
+bool LLImageDecodeThread::ImageRequest::processRequest()
 {
-        bool decoded = false;
+        const F32 decode_time_slice = .1f;
-        if(mDecodedImage.isNull())
+        bool done = true;
+        if (!mDecodedRaw && mFormattedImage.notNull())
        {
-                if (!mFormattedImage->updateData())
+                // Decode primary channels
-                {
+                if (mDecodedImageRaw.isNull())
-                        mDecodedType = -2; // failed
-                        return true;
-                }
-                if (mDiscardLevel >= 0)
                {
-                        mFormattedImage->setDiscardLevel(mDiscardLevel);
+                        // parse formatted header
-                }
+                        if (!mFormattedImage->updateData())
-                if (!(mFormattedImage->getWidth() * mFormattedImage->getHeight() * mFormattedImage->getComponents()))
+                        {
-                {
+                                return true; // done (failed)
-                        decoded = true; // failed
+                        }
-                }
+                        if (!(mFormattedImage->getWidth() * mFormattedImage->getHeight() * mFormattedImage->getComponents()))
-                else
+                        {
-                {
+                                return true; // done (failed)
-                        mDecodedImage = new LLImageRaw(); // allow possibly smaller size set during decoding
+                        }
+                        if (mDiscardLevel >= 0)
+                        {
+                                mFormattedImage->setDiscardLevel(mDiscardLevel);
+                        }
+                        mDecodedImageRaw = new LLImageRaw(mFormattedImage->getWidth(),
+                                                                                          mFormattedImage->getHeight(),
+                                                                                          mFormattedImage->getComponents());
                }
+                done = mFormattedImage->decode(mDecodedImageRaw, decode_time_slice); // 1ms
+                mDecodedRaw = done;
        }
-        if (!decoded)
+        if (done && mNeedsAux && !mDecodedAux && mFormattedImage.notNull())
        {
-                if (param == 0)
+                // Decode aux channel
-                {
+                if (!mDecodedImageAux)
-                        // Decode primary channels
-                        decoded = mFormattedImage->decode(mDecodedImage, .1f); // 1ms
-                }
-                else
                {
-                        // Decode aux channel
+                        mDecodedImageAux = new LLImageRaw(mFormattedImage->getWidth(),
-                        decoded = mFormattedImage->decodeChannels(mDecodedImage, .1f, param, param); // 1ms
+                                                                                          mFormattedImage->getHeight(),
+                                                                                          1);
                }
+                done = mFormattedImage->decodeChannels(mDecodedImageAux, decode_time_slice, 4, 4); // 1ms
+                mDecodedAux = done;
        }
-        if (decoded)
-        {
-                // Call the callback immediately; endWork doesn't get called until ckeckWork
-                if (mResponder.notNull())
-                {
-                        bool success = (!wasAborted() && mDecodedImage.notNull() && mDecodedImage->getDataSize() != 0);
-                        mResponder->completed(success);
-                }
-        }
-        return decoded;
-}
-void LLImageWorker::endWork(S32 param, bool aborted)
+        return done;
-{
-        if (mDecodedType != -2)
-        {
-                mDecodedType = aborted ? -2 : param;
-        }
 }
-//----------------------------------------------------------------------------
+void LLImageDecodeThread::ImageRequest::finishRequest(bool completed)
-BOOL LLImageWorker::requestDecodedAuxData(LLPointer<LLImageRaw>& raw, S32 channel, S32 discard)
 {
-        // For most codecs, only mDiscardLevel data is available.
+        if (mResponder.notNull())
-        //  (see LLImageDXT for exception)
-        if (discard >= 0 && discard != mFormattedImage->getDiscardLevel())
-        {
-                llerrs << "Request for invalid discard level" << llendl;
-        }
-        checkWork();
-        if (mDecodedType == -2)
        {
-                return TRUE; // aborted, done
+                bool success = completed && mDecodedRaw && (!mNeedsAux || mDecodedAux);
-        }
+                mResponder->completed(success, mDecodedImageRaw, mDecodedImageAux);
-        if (mDecodedType != channel)
-        {
-                if (!haveWork())
-                {
-                        addWork(channel, mPriority);
-                }
-                return FALSE;
-        }
-        else
-        {
-                llassert_always(!haveWork());
-                llassert_always(mDecodedType == channel);
-                raw = mDecodedImage; // smart pointer acquires ownership of data
-                mDecodedImage = NULL;
-                return TRUE;
        }
+        // Will automatically be deleted
 }
-BOOL LLImageWorker::requestDecodedData(LLPointer<LLImageRaw>& raw, S32 discard)
+// Used by unit test only
+// Checks that a responder exists for this instance so that something can happen when completion is reached
+bool LLImageDecodeThread::ImageRequest::tut_isOK()
 {
-        if (mFormattedImage->getCodec() == IMG_CODEC_DXT)
+        return mResponder.notNull();
-        {
-                // special case
-                LLImageDXT* imagedxt = (LLImageDXT*)((LLImageFormatted*)mFormattedImage);
-                return imagedxt->getMipData(raw, discard);
-        }
-        else
-        {
-                return requestDecodedAuxData(raw, 0, discard);
-        }
 }
diff --git a/linden/indra/llimage/llimageworker.h b/linden/indra/llimage/llimageworker.h
index 879fcf5..fcd3039 100644
--- a/linden/indra/llimage/llimageworker.h
+++ b/linden/indra/llimage/llimageworker.h
@@ -34,51 +34,74 @@
 #define LL_LLIMAGEWORKER_H
 #include "llimage.h"
-#include "llworkerthread.h"
+#include "llqueuedthread.h"
-class LLImageWorker : public LLWorkerClass
+class LLImageDecodeThread : public LLQueuedThread
 {
 public:
-        static void initImageWorker(LLWorkerThread* workerthread);
+        class Responder : public LLThreadSafeRefCount
-        static void cleanupImageWorker();
+        {
-        
+        protected:
-public:
+                virtual ~Responder();
-        static LLWorkerThread* getWorkerThread() { return sWorkerThread; }
+        public:
+                virtual void completed(bool success, LLImageRaw* raw, LLImageRaw* aux) = 0;
-        // LLWorkerThread
+        };
-public:
-        LLImageWorker(LLImageFormatted* image, U32 priority, S32 discard,
-                                  LLPointer<LLResponder> responder);
-        ~LLImageWorker();
-        // called from WORKER THREAD, returns TRUE if done
-        /*virtual*/ bool doWork(S32 param);
-        
-        BOOL requestDecodedData(LLPointer<LLImageRaw>& raw, S32 discard = -1);
-        BOOL requestDecodedAuxData(LLPointer<LLImageRaw>& raw, S32 channel, S32 discard = -1);
-        void releaseDecodedData();
-        void cancelDecode();
-private:
+        class ImageRequest : public LLQueuedThread::QueuedRequest
-        // called from MAIN THREAD
+        {
-        /*virtual*/ void startWork(S32 param); // called from addWork()
+        protected:
-        /*virtual*/ void endWork(S32 param, bool aborted); // called from doWork()
+                virtual ~ImageRequest(); // use deleteRequest()
+                
+        public:
+                ImageRequest(handle_t handle, LLImageFormatted* image,
+                                         U32 priority, S32 discard, BOOL needs_aux,
+                                         LLImageDecodeThread::Responder* responder);
-protected:
+                /*virtual*/ bool processRequest();
-        LLPointer<LLImageFormatted> mFormattedImage;
+                /*virtual*/ void finishRequest(bool completed);
-        LLPointer<LLImageRaw> mDecodedImage;
-        S32 mDecodedType;
-        S32 mDiscardLevel;
-private:
+                // Used by unit tests to check the consitency of the request instance
-        U32 mPriority;
+                bool tut_isOK();
-        LLPointer<LLResponder> mResponder;
+                
+        private:
+                // input
+                LLPointer<LLImageFormatted> mFormattedImage;
+                S32 mDiscardLevel;
+                BOOL mNeedsAux;
+                // output
+                LLPointer<LLImageRaw> mDecodedImageRaw;
+                LLPointer<LLImageRaw> mDecodedImageAux;
+                BOOL mDecodedRaw;
+                BOOL mDecodedAux;
+                LLPointer<LLImageDecodeThread::Responder> mResponder;
+        };
        
-protected:
-        static LLWorkerThread* sWorkerThread;
 public:
-        static S32 sCount;
+        LLImageDecodeThread(bool threaded = true);
+        handle_t decodeImage(LLImageFormatted* image,
+                                                 U32 priority, S32 discard, BOOL needs_aux,
+                                                 Responder* responder);
+        S32 update(U32 max_time_ms);
+        // Used by unit tests to check the consistency of the thread instance
+        S32 tut_size();
+        
+private:
+        struct creation_info
+        {
+                handle_t handle;
+                LLImageFormatted* image;
+                U32 priority;
+                S32 discard;
+                BOOL needs_aux;
+                LLPointer<Responder> responder;
+                creation_info(handle_t h, LLImageFormatted* i, U32 p, S32 d, BOOL aux, Responder* r)
+                        : handle(h), image(i), priority(p), discard(d), needs_aux(aux), responder(r)
+                {}
+        };
+        typedef std::list<creation_info> creation_list_t;
+        creation_list_t mCreationList;
+        LLMutex* mCreationMutex;
 };
 #endif
diff --git a/linden/indra/llrender/llcubemap.cpp b/linden/indra/llrender/llcubemap.cpp
index 754d90c..a5c677d 100644
--- a/linden/indra/llrender/llcubemap.cpp
+++ b/linden/indra/llrender/llcubemap.cpp
@@ -94,7 +94,7 @@ void LLCubeMap::initGL()
                                mImages[i] = new LLImageGL(64, 64, 4, (use_cube_mipmaps? TRUE : FALSE));
                                mImages[i]->setTarget(mTargets[i], LLTexUnit::TT_CUBE_MAP);
                                mRawImages[i] = new LLImageRaw(64, 64, 4);
-                                mImages[i]->createGLTexture(0, mRawImages[i], texname);
+                                mImages[i]->createGLTexture(0, mRawImages[i], texname, TRUE);
                                
                                gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_CUBE_MAP, texname); 
                                mImages[i]->setAddressMode(LLTexUnit::TAM_CLAMP);
@@ -106,7 +106,7 @@ void LLCubeMap::initGL()
        }
        else
        {
-                llwarns << "Using cube map without extension!" << llendl
+                llwarns << "Using cube map without extension!" << llendl;
        }
 }
diff --git a/linden/indra/llrender/llimagegl.cpp b/linden/indra/llrender/llimagegl.cpp
index d1efb11..27b1d55 100644
--- a/linden/indra/llrender/llimagegl.cpp
+++ b/linden/indra/llrender/llimagegl.cpp
@@ -43,8 +43,6 @@
 #include "llmath.h"
 #include "llgl.h"
 #include "llrender.h"
 //----------------------------------------------------------------------------
 const F32 MIN_TEXTURE_LIFETIME = 10.f;
@@ -61,8 +59,33 @@ S32 LLImageGL::sCount					= 0;
 BOOL LLImageGL::sGlobalUseAnisotropic   = FALSE;
 F32 LLImageGL::sLastFrameTime                   = 0.f;
+BOOL LLImageGL::sAllowReadBackRaw       = FALSE ;
 std::set<LLImageGL*> LLImageGL::sImageList;
+//****************************************************************************************************
+//The below for texture auditing use only
+//****************************************************************************************************
+//-----------------------
+//debug use
+BOOL gAuditTexture = FALSE ;
+#define MAX_TEXTURE_LOG_SIZE 22 //2048 * 2048
+std::vector<S32> LLImageGL::sTextureLoadedCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
+std::vector<S32> LLImageGL::sTextureBoundCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
+std::vector<S32> LLImageGL::sTextureCurBoundCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
+S32 LLImageGL::sCurTexSizeBar = -1 ;
+S32 LLImageGL::sCurTexPickSize = -1 ;
+LLPointer<LLImageGL> LLImageGL::sDefaultTexturep = NULL;
+S32 LLImageGL::sMaxCatagories = 1 ;
+std::vector<S32> LLImageGL::sTextureMemByCategory;
+std::vector<S32> LLImageGL::sTextureMemByCategoryBound ;
+std::vector<S32> LLImageGL::sTextureCurMemByCategoryBound ;
+//------------------------
+//****************************************************************************************************
+//End for texture auditing use only
+//****************************************************************************************************
 //**************************************************************************************
 //below are functions for debug use
 //do not delete them even though they are not currently being used.
@@ -110,6 +133,20 @@ void LLImageGL::checkTexSize() const
 //**************************************************************************************
 //----------------------------------------------------------------------------
+//static 
+void LLImageGL::initClass(S32 num_catagories) 
+{
+        sMaxCatagories = num_catagories ;
+        sTextureMemByCategory.resize(sMaxCatagories);
+        sTextureMemByCategoryBound.resize(sMaxCatagories) ;
+        sTextureCurMemByCategoryBound.resize(sMaxCatagories) ;
+}
+//static 
+void LLImageGL::cleanupClass() 
+{       
+}
 //static
 S32 LLImageGL::dataFormatBits(S32 dataformat)
@@ -176,12 +213,44 @@ void LLImageGL::updateStats(F32 current_time)
        sLastFrameTime = current_time;
        sBoundTextureMemoryInBytes = sCurBoundTextureMemory;
        sCurBoundTextureMemory = 0;
+        if(gAuditTexture)
+        {
+                for(U32 i = 0 ; i < sTextureCurBoundCounter.size() ; i++)
+                {
+                        sTextureBoundCounter[i] = sTextureCurBoundCounter[i] ;
+                        sTextureCurBoundCounter[i] = 0 ;
+                }
+                for(U32 i = 0 ; i < sTextureCurMemByCategoryBound.size() ; i++)
+                {
+                        sTextureMemByCategoryBound[i] = sTextureCurMemByCategoryBound[i] ;
+                        sTextureCurMemByCategoryBound[i] = 0 ;
+                }
+        }
 }
 //static
-S32 LLImageGL::updateBoundTexMem(const S32 delta)
+S32 LLImageGL::updateBoundTexMemStatic(const S32 delta, const S32 size, S32 category)
+{
+        if(gAuditTexture)
+        {
+                sTextureCurBoundCounter[getTextureCounterIndex(size)]++ ;
+                sTextureCurMemByCategoryBound[category] += delta ;
+        }
+        
+        LLImageGL::sCurBoundTextureMemory += delta ;
+        return LLImageGL::sCurBoundTextureMemory;
+}
+S32 LLImageGL::updateBoundTexMem()const
 {
-        LLImageGL::sCurBoundTextureMemory += delta;
+        if(gAuditTexture)
+        {
+                sTextureCurBoundCounter[getTextureCounterIndex(mTextureMemory / mComponents)]++ ;
+                sTextureCurMemByCategoryBound[mCategory] += mTextureMemory ;
+        }
+        LLImageGL::sCurBoundTextureMemory += mTextureMemory ;
        return LLImageGL::sCurBoundTextureMemory;
 }
@@ -195,6 +264,7 @@ void LLImageGL::destroyGL(BOOL save_state)
                gGL.getTexUnit(stage)->unbind(LLTexUnit::TT_TEXTURE);
        }
        
+        sAllowReadBackRaw = true ;
        for (std::set<LLImageGL*>::iterator iter = sImageList.begin();
                 iter != sImageList.end(); iter++)
        {
@@ -204,7 +274,7 @@ void LLImageGL::destroyGL(BOOL save_state)
                        if (save_state && glimage->isGLTextureCreated() && glimage->mComponents)
                        {
                                glimage->mSaveData = new LLImageRaw;
-                                if(!glimage->readBackRaw(glimage->mCurrentDiscardLevel, glimage->mSaveData, false))
+                                if(!glimage->readBackRaw(glimage->mCurrentDiscardLevel, glimage->mSaveData, false)) //necessary, keep it.
                                {
                                        glimage->mSaveData = NULL ;
                                }
@@ -214,6 +284,7 @@ void LLImageGL::destroyGL(BOOL save_state)
                        stop_glerror();
                }
        }
+        sAllowReadBackRaw = false ;
 }
 //static 
@@ -231,7 +302,7 @@ void LLImageGL::restoreGL()
                {
                        if (glimage->getComponents() && glimage->mSaveData->getComponents())
                        {
-                                glimage->createGLTexture(glimage->mCurrentDiscardLevel, glimage->mSaveData);
+                                glimage->createGLTexture(glimage->mCurrentDiscardLevel, glimage->mSaveData, 0, TRUE, glimage->getCategory());
                                stop_glerror();
                        }
                        glimage->mSaveData = NULL; // deletes data
@@ -311,7 +382,7 @@ void LLImageGL::init(BOOL usemipmaps)
        mTextureState       = NO_DELETE ;
        mTextureMemory    = 0;
        mLastBindTime     = 0.f;
+        
        mTarget                   = GL_TEXTURE_2D;
        mBindTarget               = LLTexUnit::TT_TEXTURE;
        mUseMipMaps               = usemipmaps;
@@ -338,7 +409,9 @@ void LLImageGL::init(BOOL usemipmaps)
        mHasExplicitFormat = FALSE;
        mGLTextureCreated = FALSE ;
        mIsMask = FALSE;
+        mCategory = -1 ;
 }
 void LLImageGL::cleanup()
@@ -438,6 +511,10 @@ void LLImageGL::dump()
 }
 //----------------------------------------------------------------------------
+void LLImageGL::forceUpdateBindStats(void) const
+{
+        mLastBindTime = sLastFrameTime;
+}
 void LLImageGL::updateBindStats(void) const
 {       
@@ -451,7 +528,8 @@ void LLImageGL::updateBindStats(void) const
                {
                        // we haven't accounted for this texture yet this frame
                        sUniqueCount++;
-                        updateBoundTexMem(mTextureMemory);
+        
+                        updateBoundTexMem();
                        mLastBindTime = sLastFrameTime;
                }
        }
@@ -464,7 +542,7 @@ bool LLImageGL::bindError(const S32 stage) const
 }
 //virtual
-bool LLImageGL::bindDefaultImage(const S32 stage) const
+bool LLImageGL::bindDefaultImage(const S32 stage) 
 {
        return false;
 }
@@ -503,7 +581,6 @@ void LLImageGL::setImage(const LLImageRaw* imageraw)
 void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
 {
 //      LLFastTimer t1(LLFastTimer::FTM_TEMP1);
-        llpushcallstacks ;
        bool is_compressed = false;
        if (mFormatPrimary >= GL_COMPRESSED_RGBA_S3TC_DXT1_EXT && mFormatPrimary <= GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
        {
@@ -716,12 +793,10 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
        }
        stop_glerror();
        mGLTextureCreated = true;
-        llpushcallstacks ;
 }
-BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height)
+BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update)
 {
-        llpushcallstacks ;
        if (!width || !height)
        {
                return TRUE;
@@ -737,7 +812,8 @@ BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S3
                return FALSE;
        }
        
-        if (x_pos == 0 && y_pos == 0 && width == getWidth() && height == getHeight() && data_width == width && data_height == height)
+        // HACK: allow the caller to explicitly force the fast path (i.e. using glTexSubImage2D here instead of calling setImage) even when updating the full texture.
+        if (!force_fast_update && x_pos == 0 && y_pos == 0 && width == getWidth() && height == getHeight() && data_width == width && data_height == height)
        {
                setImage(datap, FALSE);
        }
@@ -810,20 +886,20 @@ BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S3
                stop_glerror();
                mGLTextureCreated = true;
        }
-        llpushcallstacks ;
        return TRUE;
 }
-BOOL LLImageGL::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height)
+BOOL LLImageGL::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update)
 {
-        return setSubImage(imageraw->getData(), imageraw->getWidth(), imageraw->getHeight(), x_pos, y_pos, width, height);
+        return setSubImage(imageraw->getData(), imageraw->getWidth(), imageraw->getHeight(), x_pos, y_pos, width, height, force_fast_update);
 }
 // Copy sub image from frame buffer
 BOOL LLImageGL::setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height)
 {
-        if (gGL.getTexUnit(0)->bind(this, true))
+        if (gGL.getTexUnit(0)->bind(this, false, true))
        {
+                //checkTexSize() ;
                glCopyTexSubImage2D(GL_TEXTURE_2D, 0, fb_x, fb_y, x_pos, y_pos, width, height);
                mGLTextureCreated = true;
                stop_glerror();
@@ -883,14 +959,14 @@ BOOL LLImageGL::createGLTexture()
        return TRUE ;
 }
-BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/)
+BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/, BOOL to_create, S32 category)
 {
-        llpushcallstacks ;
        if (gGLManager.mIsDisabled)
        {
                llwarns << "Trying to create a texture while GL is disabled!" << llendl;
                return FALSE;
        }
        mGLTextureCreated = false ;
        llassert(gGLManager.mInited);
        stop_glerror();
@@ -903,8 +979,10 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
        discard_level = llclamp(discard_level, 0, (S32)mMaxDiscardLevel);
        // Actual image width/height = raw image width/height * 2^discard_level
-        S32 w = imageraw->getWidth() << discard_level;
+        S32 raw_w = imageraw->getWidth() ;
-        S32 h = imageraw->getHeight() << discard_level;
+        S32 raw_h = imageraw->getHeight() ;
+        S32 w = raw_w << discard_level;
+        S32 h = raw_h << discard_level;
        // setSize may call destroyGLTexture if the size does not match
        setSize(w, h, imageraw->getComponents());
@@ -940,13 +1018,21 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
                }
        }
+        if(!to_create) //not create a gl texture
+        {
+                destroyGLTexture();
+                mCurrentDiscardLevel = discard_level;   
+                mLastBindTime = sLastFrameTime;
+                return TRUE ;
+        }
+        mCategory = category ;
        const U8* rawdata = imageraw->getData();
        return createGLTexture(discard_level, rawdata, FALSE, usename);
 }
 BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_hasmips, S32 usename)
 {
-        llpushcallstacks ;
        llassert(data_in);
        if (discard_level < 0)
@@ -1014,7 +1100,14 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
        if (old_name != 0)
        {
                sGlobalTextureMemoryInBytes -= mTextureMemory;
+                if(gAuditTexture)
+                {
+                        decTextureCounter() ;
+                }
                LLImageGL::deleteTextures(1, &old_name);
                stop_glerror();
        }
@@ -1022,13 +1115,15 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
        sGlobalTextureMemoryInBytes += mTextureMemory;
        setActive() ;
+        if(gAuditTexture)
+        {
+                incTextureCounter() ;
+        }
        // mark this as bound at this point, so we don't throw it out immediately
        mLastBindTime = sLastFrameTime;
-        llpushcallstacks ;
        return TRUE;
 }
+#if 0
 BOOL LLImageGL::setDiscardLevel(S32 discard_level)
 {
        llassert(discard_level >= 0);
@@ -1080,25 +1175,14 @@ BOOL LLImageGL::setDiscardLevel(S32 discard_level)
                return FALSE;
        }
 }
+#endif
-BOOL LLImageGL::isValidForSculpt(S32 discard_level, S32 image_width, S32 image_height, S32 ncomponents)
-{
-        assert_glerror();
-        S32 gl_discard = discard_level - mCurrentDiscardLevel;
-        LLGLint glwidth = 0;
-        glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_WIDTH, (GLint*)&glwidth);
-        LLGLint glheight = 0;
-        glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_HEIGHT, (GLint*)&glheight);
-        LLGLint glcomponents = 0 ;
-        glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_INTERNAL_FORMAT, (GLint*)&glcomponents);
-        assert_glerror();
-        return glwidth >= image_width && glheight >= image_height && (GL_RGB8 == glcomponents || GL_RGBA8 == glcomponents) ;
-}
 BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok)
 {
-        llpushcallstacks ;
+        // VWR-13505 : Merov : Allow gl texture read back so save texture works again (temporary)
+        //llassert_always(sAllowReadBackRaw) ;
+        //llerrs << "should not call this function!" << llendl ;
+        
        if (discard_level < 0)
        {
                discard_level = mCurrentDiscardLevel;
@@ -1201,7 +1285,7 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
                return FALSE ;
        }
        //-----------------------------------------------------------------------------------------------
-        llpushcallstacks ;
        return TRUE ;
 }
@@ -1219,12 +1303,19 @@ void LLImageGL::destroyGLTexture()
                                stop_glerror();
                        }
                }
+                
-                sGlobalTextureMemoryInBytes -= mTextureMemory;
+                if(mTextureMemory)
-                mTextureMemory = 0;
+                {
+                        if(gAuditTexture)
+                        {
+                                decTextureCounter() ;
+                        }
+                        sGlobalTextureMemoryInBytes -= mTextureMemory;
+                        mTextureMemory = 0;
+                }
+                
                LLImageGL::deleteTextures(1, &mTexName);
-                mTextureState = DELETED ;               
+                mTextureState = DELETED ;
                mTexName = 0;
                mCurrentDiscardLevel = -1 ; //invalidate mCurrentDiscardLevel.
                mGLTextureCreated = FALSE ;
@@ -1338,6 +1429,11 @@ S32 LLImageGL::getMipBytes(S32 discard_level) const
        return res;
 }
+BOOL LLImageGL::isJustBound() const
+{
+        return (BOOL)(sLastFrameTime - mLastBindTime < 0.5f);
+}
 BOOL LLImageGL::getBoundRecently() const
 {
        return (BOOL)(sLastFrameTime - mLastBindTime < MIN_TEXTURE_LIFETIME);
@@ -1539,6 +1635,87 @@ BOOL LLImageGL::getMask(const LLVector2 &tc)
        return res;
 }
+void LLImageGL::setCategory(S32 category) 
+{
+        if(!gAuditTexture)
+        {
+                return ;
+        }
+        if(mCategory != category)
+        {               
+                if(mCategory > -1)
+                {
+                        sTextureMemByCategory[mCategory] -= mTextureMemory ;
+                }
+                sTextureMemByCategory[category] += mTextureMemory ;
+                
+                mCategory = category;
+        }
+}
+//for debug use 
+//val is a "power of two" number
+S32 LLImageGL::getTextureCounterIndex(U32 val) 
+{
+        //index range is [0, MAX_TEXTURE_LOG_SIZE].
+        if(val < 2)
+        {
+                return 0 ;
+        }
+        else if(val >= (1 << MAX_TEXTURE_LOG_SIZE))
+        {
+                return MAX_TEXTURE_LOG_SIZE ;
+        }
+        else
+        {
+                S32 ret = 0 ;
+                while(val >>= 1)
+                {
+                        ++ret;
+                }
+                return ret ;
+        }
+}
+void LLImageGL::incTextureCounterStatic(U32 val, S32 ncomponents, S32 category) 
+{
+        sTextureLoadedCounter[getTextureCounterIndex(val)]++ ;
+        sTextureMemByCategory[category] += (S32)val * ncomponents ;
+}
+void LLImageGL::decTextureCounterStatic(U32 val, S32 ncomponents, S32 category) 
+{
+        sTextureLoadedCounter[getTextureCounterIndex(val)]-- ;
+        sTextureMemByCategory[category] += (S32)val * ncomponents ;
+}
+void LLImageGL::incTextureCounter() 
+{
+        sTextureLoadedCounter[getTextureCounterIndex(mTextureMemory / mComponents)]++ ;
+        sTextureMemByCategory[mCategory] += mTextureMemory ;
+}
+void LLImageGL::decTextureCounter() 
+{
+        sTextureLoadedCounter[getTextureCounterIndex(mTextureMemory / mComponents)]-- ;
+        sTextureMemByCategory[mCategory] -= mTextureMemory ;
+}
+void LLImageGL::setCurTexSizebar(S32 index, BOOL set_pick_size)
+{
+        sCurTexSizeBar = index ;
+        if(set_pick_size)
+        {
+                sCurTexPickSize = (1 << index) ;
+        }
+        else
+        {
+                sCurTexPickSize = -1 ;
+        }
+}
+void LLImageGL::resetCurTexSizebar()
+{
+        sCurTexSizeBar = -1 ;
+        sCurTexPickSize = -1 ;
+}
+//----------------------------------------------------------------------------
 //----------------------------------------------------------------------------
diff --git a/linden/indra/llrender/llimagegl.h b/linden/indra/llrender/llimagegl.h
index 2f08a5a..c8df101 100644
--- a/linden/indra/llrender/llimagegl.h
+++ b/linden/indra/llrender/llimagegl.h
@@ -46,7 +46,6 @@
 #define MEGA_BYTES_TO_BYTES(x) ((x) << 20)
 //============================================================================
 class LLImageGL : public LLRefCount
 {
        friend class LLTexUnit;
@@ -57,6 +56,7 @@ public:
        static S32 dataFormatComponents(S32 dataformat);
        void updateBindStats(void) const;
+        void forceUpdateBindStats(void) const;
        // needs to be called every frame
        static void updateStats(F32 current_time);
@@ -65,9 +65,10 @@ public:
        static void destroyGL(BOOL save_state = TRUE);
        static void restoreGL();
-        // Sometimes called externally for textures not using LLImageGL (should go away...)
+        // Sometimes called externally for textures not using LLImageGL (should go away...)     
-        static S32 updateBoundTexMem(const S32 delta);
+        static S32 updateBoundTexMemStatic(const S32 delta, const S32 size, S32 category) ;
+        S32 updateBoundTexMem()const;
+        
        static bool checkSize(S32 width, S32 height);
        
        // Not currently necessary for LLImageGL, but required in some derived classes,
@@ -89,7 +90,7 @@ protected:
 public:
        virtual void dump();    // debugging info to llinfos
        virtual bool bindError(const S32 stage = 0) const;
-        virtual bool bindDefaultImage(const S32 stage = 0) const;
+        virtual bool bindDefaultImage(const S32 stage = 0) ;
        virtual void forceImmediateUpdate() ;
        void setSize(S32 width, S32 height, S32 ncomponents);
@@ -101,20 +102,22 @@ public:
        static void setManualImage(U32 target, S32 miplevel, S32 intformat, S32 width, S32 height, U32 pixformat, U32 pixtype, const void *pixels);
        BOOL createGLTexture() ;
-        BOOL createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0);
+        BOOL createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0, BOOL to_create = TRUE, 
+                S32 category = sMaxCatagories - 1);
        BOOL createGLTexture(S32 discard_level, const U8* data, BOOL data_hasmips = FALSE, S32 usename = 0);
        void setImage(const LLImageRaw* imageraw);
        void setImage(const U8* data_in, BOOL data_hasmips = FALSE);
-        BOOL setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height);
+        BOOL setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update = FALSE);
-        BOOL setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height);
+        BOOL setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update = FALSE);
        BOOL setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height);
-        BOOL setDiscardLevel(S32 discard_level);
        // Read back a raw image for this discard level, if it exists
        BOOL readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok); 
        void destroyGLTexture();
        void setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format = 0, BOOL swap_bytes = FALSE);
        void dontDiscard() { mDontDiscard = 1; mTextureState = NO_DELETE; }
+        void setComponents(S8 ncomponents) { mComponents = ncomponents; }
        S32      getDiscardLevel() const                { return mCurrentDiscardLevel; }
        S32      getMaxDiscardLevel() const             { return mMaxDiscardLevel; }
@@ -127,6 +130,7 @@ public:
        S32  getBytes(S32 discard_level = -1) const;
        S32  getMipBytes(S32 discard_level = -1) const;
        BOOL getBoundRecently() const;
+        BOOL isJustBound() const;
        LLGLenum getPrimaryFormat() const { return mFormatPrimary; }
        BOOL getHasGLTexture() const { return mTexName != 0; }
@@ -147,8 +151,6 @@ public:
        BOOL getUseDiscard() const { return mUseMipMaps && !mDontDiscard; }
        BOOL getDontDiscard() const { return mDontDiscard; }
-        BOOL isValidForSculpt(S32 discard_level, S32 image_width, S32 image_height, S32 ncomponents) ;
        void updatePickMask(S32 width, S32 height, const U8* data_in);
        BOOL getMask(const LLVector2 &tc);
@@ -175,6 +177,7 @@ public:
        void forceActive() ;
        void setNoDelete() ;
+        void setTextureSize(S32 size) {mTextureMemory = size;}
 protected:
        void init(BOOL usemipmaps);
        virtual void cleanup(); // Clean up the LLImageGL so it can be reinitialized.  Be careful when using this in derived class destructors
@@ -183,7 +186,7 @@ public:
        // Various GL/Rendering options
        S32 mTextureMemory;
        mutable F32  mLastBindTime;     // last time this was bound, by discard level
+        
 private:
        LLPointer<LLImageRaw> mSaveData; // used for destroyGL/restoreGL
        U8* mPickMask;  //downsampled bitmap approximation of alpha channel.  NULL if no alpha channel
@@ -198,7 +201,7 @@ private:
        U16      mWidth;
        U16      mHeight;       
        S8       mCurrentDiscardLevel;
+        
 protected:
        LLGLenum mTarget;               // Normally GL_TEXTURE2D, sometimes something else (ex. cube maps)
        LLTexUnit::eTextureType mBindTarget;    // Normally TT_TEXTURE, sometimes something else (ex. cube maps)
@@ -237,7 +240,7 @@ public:
        static S32 sCount;
        
        static F32 sLastFrameTime;
+        
        static LLGLuint sCurrentBoundTextures[MAX_GL_TEXTURE_UNITS]; // Currently bound texture ID
        // Global memory statistics
@@ -253,6 +256,57 @@ public:
 #else
        BOOL getMissed() const { return FALSE; };
 #endif
+public:
+        static void initClass(S32 num_catagories) ;
+        static void cleanupClass() ;
+private:
+        static S32 sMaxCatagories ;
+        //the flag to allow to call readBackRaw(...).
+        //can be removed if we do not use that function at all.
+        static BOOL sAllowReadBackRaw ;
+//
+//****************************************************************************************************
+//The below for texture auditing use only
+//****************************************************************************************************
+private:
+        S32 mCategory ;
+public:         
+        void setCategory(S32 category) ;
+        S32  getCategory()const {return mCategory ;}
+        //for debug use: show texture size distribution 
+        //----------------------------------------
+        static LLPointer<LLImageGL> sDefaultTexturep; //default texture to replace normal textures
+        static std::vector<S32> sTextureLoadedCounter ;
+        static std::vector<S32> sTextureBoundCounter ;
+        static std::vector<S32> sTextureCurBoundCounter ;
+        static S32 sCurTexSizeBar ;
+        static S32 sCurTexPickSize ;
+        static S32 getTextureCounterIndex(U32 val) ;
+        static void incTextureCounterStatic(U32 val, S32 ncomponents, S32 category) ;
+        static void decTextureCounterStatic(U32 val, S32 ncomponents, S32 category) ;
+        static void setCurTexSizebar(S32 index, BOOL set_pick_size = TRUE) ;
+        static void resetCurTexSizebar();
+        void incTextureCounter() ;
+        void decTextureCounter() ;
+        //----------------------------------------
+        //for debug use: show texture category distribution 
+        //----------------------------------------              
+        
+        static std::vector<S32> sTextureMemByCategory;
+        static std::vector<S32> sTextureMemByCategoryBound ;
+        static std::vector<S32> sTextureCurMemByCategoryBound ;
+        //----------------------------------------      
+//****************************************************************************************************
+//End of definitions for texture auditing use only
+//****************************************************************************************************
 };
+extern BOOL gAuditTexture;
 #endif // LL_LLIMAGEGL_H
diff --git a/linden/indra/llrender/llrender.cpp b/linden/indra/llrender/llrender.cpp
index ba95a19..93ff822 100644
--- a/linden/indra/llrender/llrender.cpp
+++ b/linden/indra/llrender/llrender.cpp
@@ -177,7 +177,7 @@ void LLTexUnit::disable(void)
        }
 }
-bool LLTexUnit::bind(LLImageGL* texture, bool forceBind)
+bool LLTexUnit::bind(LLImageGL* texture, bool for_rendering, bool forceBind)
 {
        stop_glerror();
        if (mIndex < 0) return false;
@@ -192,12 +192,25 @@ bool LLTexUnit::bind(LLImageGL* texture, bool forceBind)
        
        if (!texture->getTexName()) //if texture does not exist
        {
-                //if deleted, will re-generate it immediately
+                if (texture->isDeleted())
-                texture->forceImmediateUpdate() ;
+                {
+                        // This will re-generate the texture immediately.
+                        texture->forceImmediateUpdate() ;
+                }
+                texture->forceUpdateBindStats() ;
                return texture->bindDefaultImage(mIndex);
        }
+        if(gAuditTexture && for_rendering && LLImageGL::sCurTexPickSize > 0)
+        {
+                if(texture->getWidth() * texture->getHeight() == LLImageGL::sCurTexPickSize)
+                {
+                        texture->updateBindStats();
+                        return bind(LLImageGL::sDefaultTexturep.get());
+                }
+        }
        if ((mCurrTexture != texture->getTexName()) || forceBind)
        {
                activate();
@@ -214,6 +227,7 @@ bool LLTexUnit::bind(LLImageGL* texture, bool forceBind)
                        setTextureFilteringOption(texture->mFilterOption);
                }
        }
        return true;
 }
diff --git a/linden/indra/llrender/llrender.h b/linden/indra/llrender/llrender.h
index 437c715..ce84e74 100644
--- a/linden/indra/llrender/llrender.h
+++ b/linden/indra/llrender/llrender.h
@@ -148,7 +148,7 @@ public:
        
        // Binds the LLImageGL to this texture unit 
        // (automatically enables the unit for the LLImageGL's texture type)
-        bool bind(LLImageGL* texture, bool forceBind = false);
+        bool bind(LLImageGL* texture, bool for_rendering = false, bool forceBind = false);
        // Binds a cubemap to this texture unit 
        // (automatically enables the texture unit for cubemaps)
diff --git a/linden/indra/llrender/llrendertarget.cpp b/linden/indra/llrender/llrendertarget.cpp
index b7f3177..4cf8451 100644
--- a/linden/indra/llrender/llrendertarget.cpp
+++ b/linden/indra/llrender/llrendertarget.cpp
@@ -139,7 +139,7 @@ void LLRenderTarget::addColorAttachment(U32 color_fmt)
        U32 offset = mTex.size();
        if (offset >= 4 ||
-                offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers))
+                (offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers)))
        {
                llerrs << "Too many color attachments!" << llendl;
        }
@@ -608,7 +608,7 @@ void LLMultisampleBuffer::addColorAttachment(U32 color_fmt)
        U32 offset = mTex.size();
        if (offset >= 4 ||
-                offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers))
+                (offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers)))
        {
                llerrs << "Too many color attachments!" << llendl;
        }
diff --git a/linden/indra/newview/CMakeLists.txt b/linden/indra/newview/CMakeLists.txt
index e451465..d5b50cf 100644
--- a/linden/indra/newview/CMakeLists.txt
+++ b/linden/indra/newview/CMakeLists.txt
@@ -340,6 +340,10 @@ set(viewer_SOURCE_FILES
    lltexturecache.cpp
    lltexturectrl.cpp
    lltexturefetch.cpp
+    lltextureinfo.cpp
+    lltextureinfodetails.cpp
+    lltexturestats.cpp
+    lltexturestatsuploader.cpp
    lltextureview.cpp
    lltoolbar.cpp
    lltoolbrush.cpp
@@ -760,6 +764,10 @@ set(viewer_HEADER_FILES
    lltexturecache.h
    lltexturectrl.h
    lltexturefetch.h
+    lltextureinfo.h
+    lltextureinfodetails.h
+    lltexturestats.h
+    lltexturestatsuploader.h
    lltextureview.h
    lltool.h
    lltoolbar.h
diff --git a/linden/indra/newview/app_settings/settings.xml b/linden/indra/newview/app_settings/settings.xml
index f8594ad..9fea0d8 100644
--- a/linden/indra/newview/app_settings/settings.xml
+++ b/linden/indra/newview/app_settings/settings.xml
@@ -523,6 +523,17 @@
      <key>Value</key>
      <integer>1</integer>
    </map>
+    <key>AuditTexture</key>
+    <map>
+      <key>Comment</key>
+      <string>Enable texture auditting.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
    <key>AutoAcceptNewInventory</key>
    <map>
      <key>Comment</key>
@@ -5811,6 +5822,28 @@
      <key>Value</key>
      <string>http://imprudenceviewer.org/splash/</string>
    </map>
+    <key>LogTextureDownloadsToViewerLog</key>
+    <map>
+      <key>Comment</key>
+      <string>Send texture download details to the viewer log</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
+    <key>LogTextureDownloadsToSimulator</key>
+    <map>
+      <key>Comment</key>
+      <string>Send a digest of texture info to the sim</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>Boolean</string>
+      <key>Value</key>
+      <integer>0</integer>
+    </map>
    <key>LosslessJ2CUpload</key>
    <map>
      <key>Comment</key>
@@ -9776,6 +9809,17 @@
      <key>Value</key>
      <real>20.0</real>
    </map>
+    <key>TextureLoggingThreshold</key>
+    <map>
+      <key>Comment</key>
+      <string>Specifies the byte threshold at which texture download data should be sent to the sim.</string>
+      <key>Persist</key>
+      <integer>1</integer>
+      <key>Type</key>
+      <string>U32</string>
+      <key>Value</key>
+      <integer>1</integer>
+    </map>
    <key>TextureMemory</key>
    <map>
      <key>Comment</key>
diff --git a/linden/indra/newview/llappviewer.cpp b/linden/indra/newview/llappviewer.cpp
index cdecaf4..a630beb 100644
--- a/linden/indra/newview/llappviewer.cpp
+++ b/linden/indra/newview/llappviewer.cpp
@@ -57,9 +57,12 @@
 #include "llares.h" 
 #include "llcurl.h"
 #include "llfloatersnapshot.h"
+#include "lltexturestats.h"
 #include "llviewerwindow.h"
 #include "llviewerdisplay.h"
 #include "llviewermedia.h"
 #include "llviewermessage.h"
 #include "llviewerobjectlist.h"
 #include "llworldmap.h"
@@ -435,7 +438,7 @@ static void settings_modify()
        LLVOSurfacePatch::sLODFactor *= LLVOSurfacePatch::sLODFactor; //square lod factor to get exponential range of [1,4]
        gDebugGL = gSavedSettings.getBOOL("RenderDebugGL");
        gDebugPipeline = gSavedSettings.getBOOL("RenderDebugPipeline");
-        
+        gAuditTexture = gSavedSettings.getBOOL("AuditTexture");
 #if LL_VECTORIZE
        if (gSysCPU.hasAltivec())
        {
@@ -527,7 +530,7 @@ const std::string LLAppViewer::sPerAccountSettingsName = "PerAccount";
 const std::string LLAppViewer::sCrashSettingsName = "CrashSettings"; 
 LLTextureCache* LLAppViewer::sTextureCache = NULL; 
-LLWorkerThread* LLAppViewer::sImageDecodeThread = NULL; 
+LLImageDecodeThread* LLAppViewer::sImageDecodeThread = NULL; 
 LLTextureFetch* LLAppViewer::sTextureFetch = NULL; 
 LLAppViewer::LLAppViewer() : 
@@ -1512,14 +1515,14 @@ bool LLAppViewer::initThreads()
                LLWatchdog::getInstance()->init(watchdog_killer_callback);
        }
-        LLVFSThread::initClass(enable_threads && true);
+        LLVFSThread::initClass(enable_threads && false);
-        LLLFSThread::initClass(enable_threads && true);
+        LLLFSThread::initClass(enable_threads && false);
        // Image decoding
-        LLAppViewer::sImageDecodeThread = new LLWorkerThread("ImageDecode", enable_threads && true);
+        LLAppViewer::sImageDecodeThread = new LLImageDecodeThread(enable_threads && true);
        LLAppViewer::sTextureCache = new LLTextureCache(enable_threads && true);
-        LLAppViewer::sTextureFetch = new LLTextureFetch(LLAppViewer::getTextureCache(), enable_threads && false);
+        LLAppViewer::sTextureFetch = new LLTextureFetch(LLAppViewer::getTextureCache(), sImageDecodeThread, enable_threads && true);
-        LLImage::initClass(LLAppViewer::getImageDecodeThread());
+        LLImage::initClass();
        // *FIX: no error handling here!
        return true;
diff --git a/linden/indra/newview/llappviewer.h b/linden/indra/newview/llappviewer.h
index ada5557..9d72457 100644
--- a/linden/indra/newview/llappviewer.h
+++ b/linden/indra/newview/llappviewer.h
@@ -34,7 +34,7 @@
 #define LL_LLAPPVIEWER_H
 class LLTextureCache;
-class LLWorkerThread;
+class LLImageDecodeThread;
 class LLTextureFetch;
 class LLWatchdogTimeout;
 class LLCommandLineParser;
@@ -91,7 +91,7 @@ public:
    
        // Thread accessors
        static LLTextureCache* getTextureCache() { return sTextureCache; }
-        static LLWorkerThread* getImageDecodeThread() { return sImageDecodeThread; }
+        static LLImageDecodeThread* getImageDecodeThread() { return sImageDecodeThread; }
        static LLTextureFetch* getTextureFetch() { return sTextureFetch; }
        const std::string& getSerialNumber() { return mSerialNumber; }
@@ -213,7 +213,7 @@ private:
        // Thread objects.
        static LLTextureCache* sTextureCache; 
-        static LLWorkerThread* sImageDecodeThread; 
+        static LLImageDecodeThread* sImageDecodeThread; 
        static LLTextureFetch* sTextureFetch;
        S32 mNumSessions;
diff --git a/linden/indra/newview/llassetuploadresponders.cpp b/linden/indra/newview/llassetuploadresponders.cpp
index dfd7403..700edb5 100644
--- a/linden/indra/newview/llassetuploadresponders.cpp
+++ b/linden/indra/newview/llassetuploadresponders.cpp
@@ -378,6 +378,14 @@ void LLSendTexLayerResponder::uploadComplete(const LLSD& content)
        }
 }
+void LLSendTexLayerResponder::error(U32 statusNum, const std::string& reason)
+{
+        llinfos << "status: " << statusNum << " reason: " << reason << llendl;
+        
+        // Invoke the original callback with an error result
+        LLTexLayerSetBuffer::onTextureUploadComplete(LLUUID(), (void*) mBakedUploadData, -1, LL_EXSTAT_NONE);
+        mBakedUploadData = NULL;        // deleted in onTextureUploadComplete()
+}
 LLUpdateAgentInventoryResponder::LLUpdateAgentInventoryResponder(const LLSD& post_data,
                                                                                                                                 const LLUUID& vfile_id,
diff --git a/linden/indra/newview/llassetuploadresponders.h b/linden/indra/newview/llassetuploadresponders.h
index 9ab571a..c08f299 100644
--- a/linden/indra/newview/llassetuploadresponders.h
+++ b/linden/indra/newview/llassetuploadresponders.h
@@ -83,6 +83,7 @@ public:
        ~LLSendTexLayerResponder();
        virtual void uploadComplete(const LLSD& content);
+        virtual void error(U32 statusNum, const std::string& reason);
        LLBakedUploadData * mBakedUploadData;
 };
diff --git a/linden/indra/newview/lldrawable.cpp b/linden/indra/newview/lldrawable.cpp
index 44a5de9..14aa38a 100644
--- a/linden/indra/newview/lldrawable.cpp
+++ b/linden/indra/newview/lldrawable.cpp
@@ -102,7 +102,7 @@ void LLDrawable::init()
        mVObjp   = NULL;
        // mFaces
        mSpatialGroupp = NULL;
-        mVisible = 0;
+        mVisible = sCurVisible - 2;//invisible for the current frame and the last frame.
        mRadius = 0.f;
        
        mGeneration = -1;
@@ -949,7 +949,11 @@ LLSpatialPartition* LLDrawable::getSpatialPartition()
        return retval;
 }
+BOOL LLDrawable::isRecentlyVisible() const
+{
+        //currently visible or visible in the previous frame.
+        return isVisible() || (mVisible == sCurVisible - 1)  ;
+}
 BOOL LLDrawable::isVisible() const
 {
        if (mVisible == sCurVisible)
diff --git a/linden/indra/newview/lldrawable.h b/linden/indra/newview/lldrawable.h
index 21cc0c5..71b75dc 100644
--- a/linden/indra/newview/lldrawable.h
+++ b/linden/indra/newview/lldrawable.h
@@ -50,7 +50,6 @@
 #include "llviewerobject.h"
 #include "llrect.h"
 #include "llappviewer.h" // for gFrameTimeSeconds
-#include "llimagej2c.h"
 class LLCamera;
 class LLDrawPool;
@@ -81,7 +80,8 @@ public:
        BOOL isLight() const;
-        BOOL isVisible() const;         
+        BOOL isVisible() const; 
+        BOOL isRecentlyVisible() const; 
        virtual void setVisible(LLCamera& camera_in, std::vector<LLDrawable*>* results = NULL, BOOL for_select = FALSE);
diff --git a/linden/indra/newview/lldrawpool.cpp b/linden/indra/newview/lldrawpool.cpp
index 9f05ce3..e1bf1ed 100644
--- a/linden/indra/newview/lldrawpool.cpp
+++ b/linden/indra/newview/lldrawpool.cpp
@@ -279,7 +279,7 @@ S32 LLFacePool::drawLoopSetTex(face_array_t& face_list, S32 stage)
                         iter != face_list.end(); iter++)
                {
                        LLFace *facep = *iter;
-                        gGL.getTexUnit(stage)->bind(facep->getTexture());
+                        gGL.getTexUnit(stage)->bind(facep->getTexture(), TRUE);
                        gGL.getTexUnit(0)->activate();
                        res += facep->renderIndexed();
                }
@@ -481,14 +481,13 @@ void LLRenderPass::pushBatch(LLDrawInfo& params, U32 mask, BOOL texture)
        {
                if (params.mTexture.notNull())
                {
-                        gGL.getTexUnit(0)->bind(params.mTexture.get());
+                        gGL.getTexUnit(0)->bind(params.mTexture.get(), TRUE);
                        if (params.mTextureMatrix)
                        {
                                glMatrixMode(GL_TEXTURE);
                                glLoadMatrixf((GLfloat*) params.mTextureMatrix->mMatrix);
                                gPipeline.mTextureMatrixOps++;
                        }
-                        params.mTexture->addTextureStats(params.mVSize);
                }
                else
                {
diff --git a/linden/indra/newview/lldrawpoolalpha.cpp b/linden/indra/newview/lldrawpoolalpha.cpp
index 7e470bd..4b552ac 100644
--- a/linden/indra/newview/lldrawpoolalpha.cpp
+++ b/linden/indra/newview/lldrawpoolalpha.cpp
@@ -219,7 +219,7 @@ void LLDrawPoolAlpha::render(S32 pass)
                gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
                glColor4f(1,0,0,1);
                LLViewerImage::sSmokeImagep->addTextureStats(1024.f*1024.f);
-                gGL.getTexUnit(0)->bind(LLViewerImage::sSmokeImagep.get());
+                gGL.getTexUnit(0)->bind(LLViewerImage::sSmokeImagep.get(), TRUE);
                renderAlphaHighlight(LLVertexBuffer::MAP_VERTEX |
                                                        LLVertexBuffer::MAP_TEXCOORD0);
        }
@@ -295,7 +295,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
                                {
                                        gGL.getTexUnit(0)->activate();
                                        gGL.getTexUnit(0)->bind(params.mTexture.get());
-                                        params.mTexture->addTextureStats(params.mVSize);
                                        if (params.mTextureMatrix)
                                        {
                                                glMatrixMode(GL_TEXTURE);
diff --git a/linden/indra/newview/lldrawpoolbump.cpp b/linden/indra/newview/lldrawpoolbump.cpp
index 8f5858f..ff464f7 100644
--- a/linden/indra/newview/lldrawpoolbump.cpp
+++ b/linden/indra/newview/lldrawpoolbump.cpp
@@ -309,8 +309,8 @@ void LLDrawPoolBump::endRenderPass(S32 pass)
 void LLDrawPoolBump::beginShiny(bool invisible)
 {
        LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
-        if (!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY)|| 
+        if ((!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY))|| 
-                invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY))
+                (invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY)))
        {
                return;
        }
@@ -384,8 +384,8 @@ void LLDrawPoolBump::beginShiny(bool invisible)
 void LLDrawPoolBump::renderShiny(bool invisible)
 {
        LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
-        if (!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY)|| 
+        if ((!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY))|| 
-                invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY))
+                (invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY)))
        {
                return;
        }
@@ -411,8 +411,8 @@ void LLDrawPoolBump::renderShiny(bool invisible)
 void LLDrawPoolBump::endShiny(bool invisible)
 {
        LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
-        if (!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY)|| 
+        if ((!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY))|| 
-                invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY))
+                (invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY)))
        {
                return;
        }
@@ -1221,7 +1221,7 @@ void LLDrawPoolBump::pushBatch(LLDrawInfo& params, U32 mask, BOOL texture)
                if (params.mTexture.notNull())
                {
                        gGL.getTexUnit(diffuse_channel)->bind(params.mTexture.get());
-                        params.mTexture->addTextureStats(params.mVSize);
+                        //params.mTexture->addTextureStats(params.mVSize);
                }
                else
                {
diff --git a/linden/indra/newview/lldrawpoolterrain.cpp b/linden/indra/newview/lldrawpoolterrain.cpp
index 2c644b0..cac5162 100644
--- a/linden/indra/newview/lldrawpoolterrain.cpp
+++ b/linden/indra/newview/lldrawpoolterrain.cpp
@@ -83,7 +83,7 @@ LLDrawPoolTerrain::LLDrawPoolTerrain(LLViewerImage *texturep) :
        gGL.getTexUnit(0)->bind(m2DAlphaRampImagep.get());
        m2DAlphaRampImagep->setAddressMode(LLTexUnit::TAM_CLAMP);
        
-        mTexturep->setBoostLevel(LLViewerImage::BOOST_TERRAIN);
+        mTexturep->setBoostLevel(LLViewerImageBoostLevel::BOOST_TERRAIN);
        
        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
 }
@@ -170,7 +170,7 @@ void LLDrawPoolTerrain::render(S32 pass)
        LLVLComposition *compp = regionp->getComposition();
        for (S32 i = 0; i < 4; i++)
        {
-                compp->mDetailTextures[i]->setBoostLevel(LLViewerImage::BOOST_TERRAIN);
+                compp->mDetailTextures[i]->setBoostLevel(LLViewerImageBoostLevel::BOOST_TERRAIN);
                compp->mDetailTextures[i]->addTextureStats(1024.f*1024.f); // assume large pixel area
        }
diff --git a/linden/indra/newview/lldrawpooltree.cpp b/linden/indra/newview/lldrawpooltree.cpp
index 2f2b072..46cd2d5 100644
--- a/linden/indra/newview/lldrawpooltree.cpp
+++ b/linden/indra/newview/lldrawpooltree.cpp
@@ -247,7 +247,7 @@ void LLDrawPoolTree::renderTree(BOOL selecting)
        LLGLState normalize(GL_NORMALIZE, TRUE);
        
        // Bind the texture for this tree.
-        gGL.getTexUnit(sDiffTex)->bind(mTexturep.get());
+        gGL.getTexUnit(sDiffTex)->bind(mTexturep.get(), TRUE);
                
        U32 indices_drawn = 0;
diff --git a/linden/indra/newview/lldynamictexture.cpp b/linden/indra/newview/lldynamictexture.cpp
index 62fcf60..61f5a89 100644
--- a/linden/indra/newview/lldynamictexture.cpp
+++ b/linden/indra/newview/lldynamictexture.cpp
@@ -111,7 +111,7 @@ void LLDynamicTexture::generateGLTexture(LLGLint internal_format, LLGLenum prima
                mTexture->setExplicitFormat(internal_format, primary_format, type_format, swap_bytes);
        }
 //      llinfos << "ALLOCATING " << (mWidth*mHeight*mComponents)/1024 << "K" << llendl;
-        mTexture->createGLTexture(0, raw_image);
+        mTexture->createGLTexture(0, raw_image, 0, TRUE, LLViewerImageBoostLevel::DYNAMIC_TEX);
        mTexture->setAddressMode((mClamp) ? LLTexUnit::TAM_CLAMP : LLTexUnit::TAM_WRAP);
        mTexture->setGLTextureCreated(false);
 }
diff --git a/linden/indra/newview/llface.cpp b/linden/indra/newview/llface.cpp
index 69edcca..dab1dac 100644
--- a/linden/indra/newview/llface.cpp
+++ b/linden/indra/newview/llface.cpp
@@ -52,6 +52,7 @@
 #include "llvovolume.h"
 #include "pipeline.h"
 #include "llviewerregion.h"
+#include "llviewerwindow.h"
 #define LL_MAX_INDICES_COUNT 1000000
@@ -174,11 +175,19 @@ void LLFace::init(LLDrawable* drawablep, LLViewerObject* objp)
        mLastGeomIndex = mGeomIndex;
        mLastIndicesCount = mIndicesCount;
        mLastIndicesIndex = mIndicesIndex;
+        mImportanceToCamera = 0.f ;
+        mBoundingSphereRadius = 0.0f ;
 }
 void LLFace::destroy()
 {
+        if(mTexture.notNull())
+        {
+                mTexture->removeFace(this) ;
+        }
+        
        if (mDrawPoolp)
        {
                mDrawPoolp->removeFace(this);
@@ -199,7 +208,7 @@ void LLFace::destroy()
                        }
                }
        }
+        
        setDrawInfo(NULL);
        
        mDrawablep = NULL;
@@ -247,9 +256,29 @@ void LLFace::setPool(LLFacePool* new_pool, LLViewerImage *texturep)
                }
                mDrawPoolp = new_pool;
        }
-        mTexture = texturep;
+        
+        setTexture(texturep) ;
 }
+void LLFace::setTexture(LLViewerImage* tex) 
+{
+        if(mTexture == tex)
+        {
+                return ;
+        }
+        if(mTexture.notNull())
+        {
+                mTexture->removeFace(this) ;
+        }
+        
+        mTexture = tex ;
+        
+        if(mTexture.notNull())
+        {
+                mTexture->addFace(this) ;
+        } 
+}
 void LLFace::setTEOffset(const S32 te_offset)
 {
@@ -698,7 +727,9 @@ BOOL LLFace::genVolumeBBoxes(const LLVolume &volume, S32 f,
                }
                mCenterLocal = (newMin+newMax)*0.5f;
-                
+                LLVector3 tmp = (newMin - newMax) ;
+                mBoundingSphereRadius = tmp.length() * 0.5f ;
                updateCenterAgent();
        }
@@ -865,6 +896,7 @@ BOOL LLFace::getGeometryVolume(const LLVolume& volume,
        {
                mVertexBuffer->getBinormalStrider(binormals, mGeomIndex);
        }
        if (rebuild_tcoord)
        {
                mVertexBuffer->getTexCoord0Strider(tex_coords, mGeomIndex);
@@ -959,7 +991,7 @@ BOOL LLFace::getGeometryVolume(const LLVolume& volume,
                        0.75f
                };
-                if (getPoolType() != LLDrawPool::POOL_ALPHA && (LLPipeline::sRenderDeferred || LLPipeline::sRenderBump && tep->getShiny()))
+                if (getPoolType() != LLDrawPool::POOL_ALPHA && (LLPipeline::sRenderDeferred || (LLPipeline::sRenderBump && tep->getShiny())))
                {
                        color.mV[3] = U8 (alpha[tep->getShiny()] * 255);
                }
@@ -1147,6 +1179,159 @@ BOOL LLFace::getGeometryVolume(const LLVolume& volume,
        return TRUE;
 }
+const F32 LEAST_IMPORTANCE = 0.05f ;
+const F32 LEAST_IMPORTANCE_FOR_LARGE_IMAGE = 0.3f ;
+F32 LLFace::getTextureVirtualSize()
+{
+        F32 radius;
+        F32 cos_angle_to_view_dir;
+        mPixelArea = calcPixelArea(cos_angle_to_view_dir, radius);
+        if (mPixelArea <= 0)
+        {
+                return 0.f;
+        }
+        //get area of circle in texture space
+        LLVector2 tdim = mTexExtents[1] - mTexExtents[0];
+        F32 texel_area = (tdim * 0.5f).lengthSquared()*3.14159f;
+        if (texel_area <= 0)
+        {
+                // Probably animated, use default
+                texel_area = 1.f;
+        }
+        F32 face_area;
+        if (mVObjp->isSculpted() && texel_area > 1.f)
+        {
+                //sculpts can break assumptions about texel area
+                face_area = mPixelArea;
+        }
+        else
+        {
+                //apply texel area to face area to get accurate ratio
+                //face_area /= llclamp(texel_area, 1.f/64.f, 16.f);
+                face_area =  mPixelArea / llclamp(texel_area, 0.015625f, 1024.f);
+        }
+        if(face_area > LLViewerImage::sMaxSmallImageSize)
+        {
+                if(mImportanceToCamera < LEAST_IMPORTANCE) //if the face is not important, do not load hi-res.
+                {
+                        face_area = LLViewerImage::sMaxSmallImageSize ;
+                }
+                else if(face_area > LLViewerImage::sMinLargeImageSize) //if is large image, shrink face_area by considering the partial overlapping.
+                {
+                        if(mImportanceToCamera < LEAST_IMPORTANCE_FOR_LARGE_IMAGE)//if the face is not important, do not load hi-res.
+                        {
+                                face_area = LLViewerImage::sMinLargeImageSize ;
+                        }       
+                        else if(mTexture.notNull() && mTexture->isLargeImage())
+                        {               
+                                face_area *= adjustPartialOverlapPixelArea(cos_angle_to_view_dir, radius );
+                        }                       
+                }
+        }
+        return face_area;
+}
+F32 LLFace::calcPixelArea(F32& cos_angle_to_view_dir, F32& radius)
+{
+        //get area of circle around face
+        LLVector3 center = getPositionAgent();
+        LLVector3 size = (mExtents[1] - mExtents[0]) * 0.5f;
+        
+        LLVector3 lookAt = center - LLViewerCamera::getInstance()->getOrigin();
+        F32 dist = lookAt.normVec() ;
+        //get area of circle around node
+        F32 app_angle = atanf(size.length()/dist);
+        radius = app_angle*LLDrawable::sCurPixelAngle;
+        F32 face_area = radius*radius * 3.14159f;
+        if(dist < mBoundingSphereRadius) //camera is very close
+        {
+                cos_angle_to_view_dir = 1.0f ;
+                mImportanceToCamera = 1.0f ;
+        }
+        else
+        {
+                cos_angle_to_view_dir = lookAt * LLViewerCamera::getInstance()->getXAxis() ;    
+                mImportanceToCamera = LLFace::calcImportanceToCamera(cos_angle_to_view_dir, dist) ;
+        }
+        return face_area ;
+}
+//the projection of the face partially overlaps with the screen
+F32 LLFace::adjustPartialOverlapPixelArea(F32 cos_angle_to_view_dir, F32 radius )
+{
+        F32 screen_radius = (F32)llmax(gViewerWindow->getWindowDisplayWidth(), gViewerWindow->getWindowDisplayHeight()) ;
+        F32 center_angle = acosf(cos_angle_to_view_dir) ;
+        F32 d = center_angle * LLDrawable::sCurPixelAngle ;
+        if(d + radius > screen_radius + 5.f)
+        {
+                //----------------------------------------------
+                //calculate the intersection area of two circles
+                //F32 radius_square = radius * radius ;
+                //F32 d_square = d * d ;
+                //F32 screen_radius_square = screen_radius * screen_radius ;
+                //face_area = 
+                //      radius_square * acosf((d_square + radius_square - screen_radius_square)/(2 * d * radius)) +
+                //      screen_radius_square * acosf((d_square + screen_radius_square - radius_square)/(2 * d * screen_radius)) -
+                //      0.5f * sqrtf((-d + radius + screen_radius) * (d + radius - screen_radius) * (d - radius + screen_radius) * (d + radius + screen_radius)) ;                      
+                //----------------------------------------------
+                //the above calculation is too expensive
+                //the below is a good estimation: bounding box of the bounding sphere:
+                F32 alpha = 0.5f * (radius + screen_radius - d) / radius ;
+                alpha = llclamp(alpha, 0.f, 1.f) ;
+                return alpha * alpha ;
+        }
+        return 1.0f ;
+}
+const S8 FACE_IMPORTANCE_LEVEL = 4 ;
+const F32 FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[FACE_IMPORTANCE_LEVEL][2] = //{distance, importance_weight}
+        {{16.1f, 1.0f}, {32.1f, 0.5f}, {48.1f, 0.2f}, {96.1f, 0.05f} } ;
+const F32 FACE_IMPORTANCE_TO_CAMERA_OVER_ANGLE[FACE_IMPORTANCE_LEVEL][2] =    //{cos(angle), importance_weight}
+        {{0.985f /*cos(10 degrees)*/, 1.0f}, {0.94f /*cos(20 degrees)*/, 0.8f}, {0.866f /*cos(30 degrees)*/, 0.64f}, {0.0f, 0.36f}} ;
+//static 
+F32 LLFace::calcImportanceToCamera(F32 cos_angle_to_view_dir, F32 dist)
+{
+        F32 importance = 0.f ;
+        
+        if(cos_angle_to_view_dir > LLViewerCamera::getInstance()->getCosHalfFov() && 
+                dist < FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[FACE_IMPORTANCE_LEVEL - 1][0]) 
+        {
+                F32 camera_moving_speed = LLViewerCamera::getInstance()->getAverageSpeed() ;
+                F32 camera_angular_speed = LLViewerCamera::getInstance()->getAverageAngularSpeed();
+                if(camera_moving_speed > 10.0f || camera_angular_speed > 1.0f)
+                {
+                        //if camera moves or rotates too fast, ignore the importance factor
+                        return 0.f ;
+                }
+                
+                //F32 camera_relative_speed = camera_moving_speed * (lookAt * LLViewerCamera::getInstance()->getVelocityDir()) ;
+                
+                S32 i = 0 ;
+                for(i = 0; i < FACE_IMPORTANCE_LEVEL && dist > FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[i][0]; ++i);
+                i = llmin(i, FACE_IMPORTANCE_LEVEL - 1) ;
+                F32 dist_factor = FACE_IMPORTANCE_TO_CAMERA_OVER_DISTANCE[i][1] ;
+                
+                for(i = 0; i < FACE_IMPORTANCE_LEVEL && cos_angle_to_view_dir < FACE_IMPORTANCE_TO_CAMERA_OVER_ANGLE[i][0] ; ++i) ;
+                i = llmin(i, FACE_IMPORTANCE_LEVEL - 1) ;
+                importance = dist_factor * FACE_IMPORTANCE_TO_CAMERA_OVER_ANGLE[i][1] ;
+        }
+        return importance ;
+}
 BOOL LLFace::verify(const U32* indices_array) const
 {
        BOOL ok = TRUE;
diff --git a/linden/indra/newview/llface.h b/linden/indra/newview/llface.h
index 4a551ff..5e422b4 100644
--- a/linden/indra/newview/llface.h
+++ b/linden/indra/newview/llface.h
@@ -88,7 +88,7 @@ public:
        U16                             getGeomIndex()          const   { return mGeomIndex; }          // index into draw pool
        U16                             getGeomStart()          const   { return mGeomIndex; }          // index into draw pool
        LLViewerImage*  getTexture()            const   { return mTexture; }
-        void                    setTexture(LLViewerImage* tex) { mTexture = tex; }
+        void                    setTexture(LLViewerImage* tex) ;
        LLXformMatrix*  getXform()                      const   { return mXform; }
        BOOL                    hasGeometry()           const   { return mGeomCount > 0; }
        LLVector3               getPositionAgent()      const;
@@ -186,7 +186,14 @@ public:
        void            setIndicesIndex(S32 idx) { mIndicesIndex = idx; }
        void            setDrawInfo(LLDrawInfo* draw_info);
-protected:
+        F32         getTextureVirtualSize() ;
+        F32         getImportanceToCamera()const {return mImportanceToCamera ;}
+private:        
+        F32         adjustPartialOverlapPixelArea(F32 cos_angle_to_view_dir, F32 radius );
+        F32         calcPixelArea(F32& cos_angle_to_view_dir, F32& radius) ;
+public:
+        static F32  calcImportanceToCamera(F32 to_view_dir, F32 dist);
 public:
        
@@ -202,7 +209,7 @@ public:
        LLMatrix4*      mTextureMatrix;
        LLDrawInfo* mDrawInfo;
-protected:
+private:
        friend class LLGeometryManager;
        friend class LLVolumeGeometryManager;
@@ -231,7 +238,13 @@ protected:
        S32                     mReferenceIndex;
        F32                     mVSize;
        F32                     mPixelArea;
-        
+        //importance factor, in the range [0, 1.0].
+        //1.0: the most important.
+        //based on the distance from the face to the view point and the angle from the face center to the view direction.
+        F32         mImportanceToCamera ; 
+        F32         mBoundingSphereRadius ;
 protected:
        static BOOL     sSafeRenderSelect;
        
diff --git a/linden/indra/newview/llfloaterassetbrowser.cpp b/linden/indra/newview/llfloaterassetbrowser.cpp
index cb2412d..af81c4a 100644
--- a/linden/indra/newview/llfloaterassetbrowser.cpp
+++ b/linden/indra/newview/llfloaterassetbrowser.cpp
@@ -130,7 +130,7 @@ void LLFloaterAssetBrowser::createThumbnails()
        for(S32 i = 0; i < items.count(); i++)
        {
                        mTextureAssets[i].mTexturep = gImageList.getImage(mTextureAssets[i].mAssetUUID, MIPMAP_YES, IMMEDIATE_NO);
-                        mTextureAssets[i].mTexturep->setBoostLevel(LLViewerImage::BOOST_PREVIEW);
+                        mTextureAssets[i].mTexturep->setBoostLevel(LLViewerImageBoostLevel::BOOST_PREVIEW);
                        //mTextureAssets[i].mTexturep->processTextureStats();
        }
diff --git a/linden/indra/newview/llfloaterreporter.cpp b/linden/indra/newview/llfloaterreporter.cpp
index 31d658b..7a5f2ba 100644
--- a/linden/indra/newview/llfloaterreporter.cpp
+++ b/linden/indra/newview/llfloaterreporter.cpp
@@ -952,8 +952,8 @@ void LLFloaterReporter::takeScreenshot()
                                                mResourceDatap->mAssetInfo.mType);
        // store in the image list so it doesn't try to fetch from the server
-        LLPointer<LLViewerImage> image_in_list = new LLViewerImage(mResourceDatap->mAssetInfo.mUuid, TRUE);
+        LLPointer<LLViewerImage> image_in_list = new LLViewerImage(mResourceDatap->mAssetInfo.mUuid);
-        image_in_list->createGLTexture(0, raw);
+        image_in_list->createGLTexture(0, raw, 0, TRUE, LLViewerImageBoostLevel::OTHER);
        gImageList.addImage(image_in_list); 
        // the texture picker then uses that texture
diff --git a/linden/indra/newview/llpreviewtexture.cpp b/linden/indra/newview/llpreviewtexture.cpp
index 13e7cca..dcbb669 100644
--- a/linden/indra/newview/llpreviewtexture.cpp
+++ b/linden/indra/newview/llpreviewtexture.cpp
@@ -224,6 +224,11 @@ void LLPreviewTexture::draw()
                        // Pump the texture priority
                        F32 pixel_area = mLoadingFullImage ? (F32)MAX_IMAGE_AREA  : (F32)(interior.getWidth() * interior.getHeight() );
                        mImage->addTextureStats( pixel_area );
+                        if(pixel_area > 0.f)
+                        {
+                                //boost the previewed image priority to the highest to make it to get loaded first.
+                                mImage->setAdditionalDecodePriority(1.0f) ;
+                        }
                        // Don't bother decoding more than we can display, unless
                        // we're loading the full image.
@@ -482,7 +487,8 @@ void LLPreviewTexture::updateDimensions()
 void LLPreviewTexture::loadAsset()
 {
        mImage = gImageList.getImage(mImageID, MIPMAP_TRUE, FALSE);
-        mImage->setBoostLevel(LLViewerImage::BOOST_PREVIEW);
+        mImage->setBoostLevel(LLViewerImageBoostLevel::BOOST_PREVIEW);
+        mImage->forceToSaveRawImage(0) ;
        mAssetStatus = PREVIEW_ASSET_LOADING;
 }
diff --git a/linden/indra/newview/llstartup.cpp b/linden/indra/newview/llstartup.cpp
index 143aa34..7a7e023 100644
--- a/linden/indra/newview/llstartup.cpp
+++ b/linden/indra/newview/llstartup.cpp
@@ -59,6 +59,7 @@
 #include "llfocusmgr.h"
 #include "llhttpsender.h"
 #include "imageids.h"
+#include "llimageworker.h"
 #include "lllandmark.h"
 #include "llloginflags.h"
 #include "llmd5.h"
@@ -3468,7 +3469,7 @@ void init_start_screen(S32 location_id)
        }
        raw->expandToPowerOfTwo();
-        gStartImageGL->createGLTexture(0, raw);
+        gStartImageGL->createGLTexture(0, raw, 0, TRUE, LLViewerImageBoostLevel::OTHER);
 }
diff --git a/linden/indra/newview/lltexlayer.cpp b/linden/indra/newview/lltexlayer.cpp
index 424c525..968c496 100644
--- a/linden/indra/newview/lltexlayer.cpp
+++ b/linden/indra/newview/lltexlayer.cpp
@@ -115,7 +115,6 @@ LLTexLayerSetBuffer::~LLTexLayerSetBuffer()
        if( mBumpTex.notNull())
        {
                mBumpTex = NULL ;
-                LLImageGL::sGlobalTextureMemoryInBytes -= mWidth * mHeight * 4;
                LLTexLayerSetBuffer::sGLBumpByteCount -= mWidth * mHeight * 4;
        }
 }
@@ -132,7 +131,7 @@ void LLTexLayerSetBuffer::destroyGLTexture()
        if( mBumpTex.notNull() )
        {
                mBumpTex = NULL ;
-                LLImageGL::sGlobalTextureMemoryInBytes -= mWidth * mHeight * 4;
+                //LLImageGL::sGlobalTextureMemoryInBytes -= mWidth * mHeight * 4;
                LLTexLayerSetBuffer::sGLBumpByteCount -= mWidth * mHeight * 4;
        }
@@ -165,6 +164,14 @@ void LLTexLayerSetBuffer::createBumpTexture()
                LLImageGL::sGlobalTextureMemoryInBytes += mWidth * mHeight * 4;
                LLTexLayerSetBuffer::sGLBumpByteCount += mWidth * mHeight * 4;
+                if(gAuditTexture)
+                {
+                        mBumpTex->setCategory(LLViewerImageBoostLevel::TEXLAYER_BUMP) ;
+                        mBumpTex->setTextureSize(mWidth * mHeight * 4) ;
+                        mBumpTex->setComponents(4) ;
+                        mBumpTex->incTextureCounter() ;
+                }
        }
 }
@@ -619,7 +626,7 @@ void LLTexLayerSetBuffer::bindBumpTexture( U32 stage )
                if( mLastBindTime != LLImageGL::sLastFrameTime )
                {
                        mLastBindTime = LLImageGL::sLastFrameTime;
-                        LLImageGL::updateBoundTexMem(mWidth * mHeight * 4);
+                        mBumpTex->updateBoundTexMem();
                }
        }
        else
@@ -833,7 +840,7 @@ BOOL LLTexLayerSet::render( S32 x, S32 y, S32 width, S32 height )
                        if( image_gl )
                        {
                                LLGLSUIDefault gls_ui;
-                                gGL.getTexUnit(0)->bind(image_gl);
+                                gGL.getTexUnit(0)->bind(image_gl, TRUE);
                                gGL.getTexUnit(0)->setTextureBlendType( LLTexUnit::TB_REPLACE );
                                gl_rect_2d_simple_tex( width, height );
                        }
@@ -1418,7 +1425,7 @@ BOOL LLTexLayer::render( S32 x, S32 y, S32 width, S32 height )
                                        LLTexUnit::eTextureAddressMode old_mode = image_gl->getAddressMode();
                                        
-                                        gGL.getTexUnit(0)->bind(image_gl);
+                                        gGL.getTexUnit(0)->bind(image_gl, TRUE);
                                        gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
                                        gl_rect_2d_simple_tex( width, height );
@@ -1440,7 +1447,7 @@ BOOL LLTexLayer::render( S32 x, S32 y, S32 width, S32 height )
                        LLImageGL* image_gl = gTexStaticImageList.getImageGL( getInfo()->mStaticImageFileName, getInfo()->mStaticImageIsMask );
                        if( image_gl )
                        {
-                                gGL.getTexUnit(0)->bind(image_gl);
+                                gGL.getTexUnit(0)->bind(image_gl, TRUE);
                                gl_rect_2d_simple_tex( width, height );
                                gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                        }
@@ -1617,7 +1624,7 @@ BOOL LLTexLayer::renderAlphaMasks( S32 x, S32 y, S32 width, S32 height, LLColor4
                                        LLTexUnit::eTextureAddressMode old_mode = image_gl->getAddressMode();
                                        
-                                        gGL.getTexUnit(0)->bind(image_gl);
+                                        gGL.getTexUnit(0)->bind(image_gl, TRUE);
                                        gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
                                        gl_rect_2d_simple_tex( width, height );
@@ -1643,7 +1650,7 @@ BOOL LLTexLayer::renderAlphaMasks( S32 x, S32 y, S32 width, S32 height, LLColor4
                                        ( (image_gl->getComponents() == 1) && getInfo()->mStaticImageIsMask ) )
                                {
                                        LLGLSNoAlphaTest gls_no_alpha_test;
-                                        gGL.getTexUnit(0)->bind(image_gl);
+                                        gGL.getTexUnit(0)->bind(image_gl, TRUE);
                                        gl_rect_2d_simple_tex( width, height );
                                        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                                }
@@ -2088,14 +2095,14 @@ BOOL LLTexLayerParamAlpha::render( S32 x, S32 y, S32 width, S32 height )
                                // Create the GL texture, and then hang onto it for future use.
                                if( mNeedsCreateTexture )
                                {
-                                        mCachedProcessedImageGL->createGLTexture(0, mStaticImageRaw);
+                                        mCachedProcessedImageGL->createGLTexture(0, mStaticImageRaw, 0, TRUE, LLViewerImageBoostLevel::TEXLAYER_CACHE);
                                        mNeedsCreateTexture = FALSE;
                                        gGL.getTexUnit(0)->bind(mCachedProcessedImageGL);
                                        mCachedProcessedImageGL->setAddressMode(LLTexUnit::TAM_CLAMP);
                                }
                                LLGLSNoAlphaTest gls_no_alpha_test;
-                                gGL.getTexUnit(0)->bind(mCachedProcessedImageGL);
+                                gGL.getTexUnit(0)->bind(mCachedProcessedImageGL, TRUE);
                                gl_rect_2d_simple_tex( width, height );
                                gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
                                stop_glerror();
@@ -2543,7 +2550,7 @@ LLImageGL* LLTexStaticImageList::getImageGL(const std::string& file_name, BOOL i
                                // that once an image is a mask it's always a mask.
                                image_gl->setExplicitFormat( GL_ALPHA8, GL_ALPHA );
                        }
-                        image_gl->createGLTexture(0, image_raw);
+                        image_gl->createGLTexture(0, image_raw, 0, TRUE, LLViewerImageBoostLevel::OTHER);
                        gGL.getTexUnit(0)->bind(image_gl);
                        image_gl->setAddressMode(LLTexUnit::TAM_CLAMP);
diff --git a/linden/indra/newview/lltexturecache.cpp b/linden/indra/newview/lltexturecache.cpp
index 9c3bed2..e0bef61 100644
--- a/linden/indra/newview/lltexturecache.cpp
+++ b/linden/indra/newview/lltexturecache.cpp
@@ -43,11 +43,18 @@
 // Included to allow LLTextureCache::purgeTextures() to pause watchdog timeout
 #include "llappviewer.h" 
-#define USE_LFS_READ 0
+// Cache organization:
-#define USE_LFS_WRITE 0
+// cache/texture.entries
+//  Unordered array of Entry structs
-// Note: first 4 bytes store file size, rest is j2c data
+// cache/texture.cache
-const S32 TEXTURE_CACHE_ENTRY_SIZE = FIRST_PACKET_SIZE; //1024;
+//  First TEXTURE_CACHE_ENTRY_SIZE bytes of each texture in texture.entries in same order
+//  Entry size same as header packet, so we're not 0-padding unless whole image is contained in header.
+// cache/textures/[0-F]/UUID.texture
+//  Actual texture body files
+const S32 TEXTURE_CACHE_ENTRY_SIZE = FIRST_PACKET_SIZE; 
+const F32 TEXTURE_CACHE_PURGE_AMOUNT = .20f; // % amount to reduce the cache by when it exceeds its limit
+const F32 TEXTURE_CACHE_LRU_SIZE = .10f; // % amount for LRU list (low overhead to regenerate)
 class LLTextureCacheWorker : public LLWorkerClass
 {
@@ -309,93 +316,74 @@ void LLTextureCacheWorker::startWork(S32 param)
 {
 }
+// This is where a texture is read from the cache system (header and body)
+// Current assumption are:
+// - the whole data are in a raw form, will be stored at mReadData
+// - the size of this raw data is mDataSize and can be smaller than TEXTURE_CACHE_ENTRY_SIZE (the size of a record in the header cache)
+// - the code supports offset reading but this is actually never exercised in the viewer
 bool LLTextureCacheRemoteWorker::doRead()
 {
+        bool done = false;
+        S32 idx = -1;
        S32 local_size = 0;
        std::string local_filename;
        
+        // First state / stage : find out if the file is local
        if (mState == INIT)
        {
                std::string filename = mCache->getLocalFileName(mID);   
-                local_filename = filename + ".j2c";
+                // Is it a JPEG2000 file? 
-                local_size = LLAPRFile::size(local_filename);
-                if (local_size == 0)
                {
-                        local_filename = filename + ".tga";
+                        local_filename = filename + ".j2c";
                        local_size = LLAPRFile::size(local_filename);
                        if (local_size > 0)
                        {
-                                mImageFormat = IMG_CODEC_TGA;
+                                mImageFormat = IMG_CODEC_J2C;
-                                mDataSize = local_size; // Only a complete .tga file is valid
                        }
                }
-                if (local_size > 0)
+                // If not, is it a jpeg file?
-                {
+                if (local_size == 0)
-                        mState = LOCAL;
-                }
-                else
-                {
-                        mState = CACHE;
-                }
-        }
-        if (mState == LOCAL)
-        {
-#if USE_LFS_READ
-                if (mFileHandle == LLLFSThread::nullHandle())
                {
-                        mImageLocal = TRUE;
+                        local_filename = filename + ".jpg";
-                        mImageSize = local_size;
+                        local_size = LLAPRFile::size(local_filename);
-                        if (!mDataSize || mDataSize + mOffset > local_size)
+                        if (local_size > 0)
-                        {
-                                mDataSize = local_size - mOffset;
-                        }
-                        if (mDataSize <= 0)
                        {
-                                // no more data to read
+                                mImageFormat = IMG_CODEC_JPEG;
-                                mDataSize = 0;
+                                mDataSize = local_size; // Only a complete .jpg file is valid
-                                return true;
                        }
-                        mReadData = new U8[mDataSize];
-                        mBytesRead = -1;
-                        mBytesToRead = mDataSize;
-                        setPriority(LLWorkerThread::PRIORITY_LOW | mPriority);
-                        mFileHandle = LLLFSThread::sLocal->read(local_filename, mReadData, mOffset, mDataSize,
-                                                                                                        new ReadResponder(mCache, mRequestHandle));
-                        return false;
                }
-                else
+                // Hmm... What about a targa file? (used for UI texture mostly)
+                if (local_size == 0)
                {
-                        if (mBytesRead >= 0)
+                        local_filename = filename + ".tga";
-                        {
+                        local_size = LLAPRFile::size(local_filename);
-                                if (mBytesRead != mBytesToRead)
+                        if (local_size > 0)
-                                {
-//                                      llwarns << "Error reading file from local cache: " << local_filename
-//                                                      << " Bytes: " << mDataSize << " Offset: " << mOffset
-//                                                      << " / " << mDataSize << llendl;
-                                        mDataSize = 0; // failed
-                                        delete[] mReadData;
-                                        mReadData = NULL;
-                                }
-                                return true;
-                        }
-                        else
                        {
-                                return false;
+                                mImageFormat = IMG_CODEC_TGA;
+                                mDataSize = local_size; // Only a complete .tga file is valid
                        }
                }
-#else
+                // Determine the next stage: if we found a file, then LOCAL else CACHE
+                mState = (local_size > 0 ? LOCAL : CACHE);
+        }
+        // Second state / stage : if the file is local, load it and leave
+        if (!done && (mState == LOCAL))
+        {
+                llassert(local_size != 0);      // we're assuming there is a non empty local file here...
                if (!mDataSize || mDataSize > local_size)
                {
                        mDataSize = local_size;
                }
+                // Allocate read buffer
                mReadData = new U8[mDataSize];
                S32 bytes_read = LLAPRFile::readEx(local_filename, mReadData, mOffset, mDataSize);
                if (bytes_read != mDataSize)
                {
-//                      llwarns << "Error reading file from local cache: " << local_filename
+                        llwarns << "Error reading file from local cache: " << local_filename
-//                                      << " Bytes: " << mDataSize << " Offset: " << mOffset
+                                        << " Bytes: " << mDataSize << " Offset: " << mOffset
-//                                      << " / " << mDataSize << llendl;
+                                        << " / " << mDataSize << llendl;
                        mDataSize = 0;
                        delete[] mReadData;
                        mReadData = NULL;
@@ -405,403 +393,273 @@ bool LLTextureCacheRemoteWorker::doRead()
                        mImageSize = local_size;
                        mImageLocal = TRUE;
                }
-                return true;
+                // We're done...
-#endif
+                done = true;
        }
-        S32 idx = -1;
+        // Second state / stage : identify the cache or not...
-        
+        if (!done && (mState == CACHE))
-        if (mState == CACHE)
        {
-                llassert_always(mImageSize == 0);
+                idx = mCache->getHeaderCacheEntry(mID, mImageSize);
-                idx = mCache->getHeaderCacheEntry(mID, false, &mImageSize);
+                if (idx < 0)
-                if (idx >= 0 && mImageSize > mOffset)
                {
-                        llassert_always(mImageSize > 0);
+                        // The texture is *not* cached. We're done here...
-                        if (!mDataSize || mDataSize > mImageSize)
+                        mDataSize = 0; // no data 
-                        {
+                        done = true;
-                                mDataSize = mImageSize;
-                        }
-                        mState = mOffset < TEXTURE_CACHE_ENTRY_SIZE ? HEADER : BODY;
                }
                else
                {
-                        mDataSize = 0; // no data
+                        // If the read offset is bigger than the header cache, we read directly from the body
-                        return true;
+                        // Note that currently, we *never* read with offset from the cache, so the result is *always* HEADER
+                        mState = mOffset < TEXTURE_CACHE_ENTRY_SIZE ? HEADER : BODY;
                }
        }
-        if (mState == HEADER)
+        // Third state / stage : read data from the header cache (texture.entries) file
+        if (!done && (mState == HEADER))
        {
-#if USE_LFS_READ
+                llassert_always(idx >= 0);      // we need an entry here or reading the header makes no sense
-                if (mFileHandle == LLLFSThread::nullHandle())
-                {
-                        llassert_always(idx >= 0);
-                        llassert_always(mOffset < TEXTURE_CACHE_ENTRY_SIZE);
-                        S32 offset = idx * TEXTURE_CACHE_ENTRY_SIZE + mOffset;
-                        S32 size = TEXTURE_CACHE_ENTRY_SIZE - mOffset;
-                        llassert_always(mReadData == NULL);
-                        mReadData = new U8[size];
-                        mBytesRead = -1;
-                        mBytesToRead = size;
-                        setPriority(LLWorkerThread::PRIORITY_LOW | mPriority);
-                        mFileHandle = LLLFSThread::sLocal->read(mCache->mHeaderDataFileName,
-                                                                                                        mReadData, offset, mBytesToRead,
-                                                                                                        new ReadResponder(mCache, mRequestHandle));
-                        return false;
-                }
-                else
-                {
-                        if (mBytesRead >= 0)
-                        {
-                                if (mBytesRead != mBytesToRead)
-                                {
-//                                      llwarns << "LLTextureCacheWorker: "  << mID
-//                                                      << " incorrect number of bytes read from header: " << mBytesRead
-//                                                      << " != " << mBytesToRead << llendl;
-                                        mDataSize = -1; // failed
-                                        return true;
-                                }
-                                if (mDataSize <= TEXTURE_CACHE_ENTRY_SIZE)
-                                {
-                                        return true; // done
-                                }
-                                else
-                                {
-                                        mFileHandle = LLLFSThread::nullHandle();
-                                        mState = BODY;
-                                }
-                        }
-                        else
-                        {
-                                return false;
-                        }
-                }
-#else
-                llassert_always(idx >= 0);
                llassert_always(mOffset < TEXTURE_CACHE_ENTRY_SIZE);
                S32 offset = idx * TEXTURE_CACHE_ENTRY_SIZE + mOffset;
+                // Compute the size we need to read (in bytes)
                S32 size = TEXTURE_CACHE_ENTRY_SIZE - mOffset;
+                size = llmin(size, mDataSize);
+                // Allocate the read buffer
                mReadData = new U8[size];
                S32 bytes_read = LLAPRFile::readEx(mCache->mHeaderDataFileName, 
                                                                                         mReadData, offset, size);
                if (bytes_read != size)
                {
-//                      llwarns << "LLTextureCacheWorker: "  << mID
+                        llwarns << "LLTextureCacheWorker: "  << mID
-//                                      << " incorrect number of bytes read from header: " << bytes_read
+                                        << " incorrect number of bytes read from header: " << bytes_read
-//                                      << " / " << size << llendl;
+                                        << " / " << size << llendl;
+                        delete[] mReadData;
+                        mReadData = NULL;
                        mDataSize = -1; // failed
-                        return true;
+                        done = true;
                }
-                if (mDataSize <= TEXTURE_CACHE_ENTRY_SIZE)
+                // If we already read all we expected, we're actually done
+                if (mDataSize <= bytes_read)
                {
-                        return true; // done
+                        done = true;
                }
                else
                {
                        mState = BODY;
                }
-#endif
        }
-        if (mState == BODY)
+        // Fourth state / stage : read the rest of the data from the UUID based cached file
+        if (!done && (mState == BODY))
        {
-#if USE_LFS_READ
-                if (mFileHandle == LLLFSThread::nullHandle())
-                {
-                        std::string filename = mCache->getTextureFileName(mID);
-                        S32 filesize = LLAPRFile::size(filename);
-                        if (filesize > mOffset)
-                        {
-                                S32 datasize = TEXTURE_CACHE_ENTRY_SIZE + filesize;
-                                mDataSize = llmin(datasize, mDataSize);
-                                S32 data_offset = TEXTURE_CACHE_ENTRY_SIZE - mOffset;
-                                data_offset = llmax(data_offset, 0);
-                                S32 file_size = mDataSize - data_offset;
-                                S32 file_offset = mOffset - TEXTURE_CACHE_ENTRY_SIZE;
-                                file_offset = llmax(file_offset, 0);
-                                llassert_always(mDataSize > 0);
-                                U8* data = new U8[mDataSize];
-                                if (data_offset > 0)
-                                {
-                                        llassert_always(mReadData);
-                                        llassert_always(data_offset <= mDataSize);
-                                        memcpy(data, mReadData, data_offset);
-                                        delete[] mReadData;
-                                        mReadData = NULL;
-                                }
-                                llassert_always(mReadData == NULL);
-                                mReadData = data;
-                                mBytesRead = -1;
-                                mBytesToRead = file_size;
-                                setPriority(LLWorkerThread::PRIORITY_LOW | mPriority);
-                                llassert_always(data_offset + mBytesToRead <= mDataSize);
-                                mFileHandle = LLLFSThread::sLocal->read(filename,
-                                                                                                                mReadData + data_offset, file_offset, mBytesToRead,
-                                                                                                                new ReadResponder(mCache, mRequestHandle));
-                                return false;
-                        }
-                        else
-                        {
-                                mDataSize = TEXTURE_CACHE_ENTRY_SIZE;
-                                return true; // done
-                        }
-                }
-                else
-                {
-                        if (mBytesRead >= 0)
-                        {
-                                if (mBytesRead != mBytesToRead)
-                                {
-//                                      llwarns << "LLTextureCacheWorker: "  << mID
-//                                                      << " incorrect number of bytes read from body: " << mBytesRead
-//                                                      << " != " << mBytesToRead << llendl;
-                                        mDataSize = -1; // failed
-                                }
-                                return true;
-                        }
-                        else
-                        {
-                                return false;
-                        }
-                }
-#else
                std::string filename = mCache->getTextureFileName(mID);
                S32 filesize = LLAPRFile::size(filename);
-                S32 bytes_read = 0;
-                if (filesize > mOffset)
+                if (filesize && (filesize + TEXTURE_CACHE_ENTRY_SIZE) > mOffset)
                {
-                        S32 datasize = TEXTURE_CACHE_ENTRY_SIZE + filesize;
+                        S32 max_datasize = TEXTURE_CACHE_ENTRY_SIZE + filesize - mOffset;
-                        mDataSize = llmin(datasize, mDataSize);
+                        mDataSize = llmin(max_datasize, mDataSize);
-                        S32 data_offset = TEXTURE_CACHE_ENTRY_SIZE - mOffset;
-                        data_offset = llmax(data_offset, 0);
+                        S32 data_offset, file_size, file_offset;
-                        S32 file_size = mDataSize - data_offset;
-                        S32 file_offset = mOffset - TEXTURE_CACHE_ENTRY_SIZE;
-                        file_offset = llmax(file_offset, 0);
                        
+                        // Reserve the whole data buffer first
                        U8* data = new U8[mDataSize];
-                        if (data_offset > 0)
+                        // Set the data file pointers taking the read offset into account. 2 cases:
+                        if (mOffset < TEXTURE_CACHE_ENTRY_SIZE)
                        {
+                                // Offset within the header record. That means we read something from the header cache.
+                                // Note: most common case is (mOffset = 0), so this is the "normal" code path.
+                                data_offset = TEXTURE_CACHE_ENTRY_SIZE - mOffset;       // i.e. TEXTURE_CACHE_ENTRY_SIZE if mOffset nul (common case)
+                                file_offset = 0;
+                                file_size = mDataSize - data_offset;
+                                // Copy the raw data we've been holding from the header cache into the new sized buffer
                                llassert_always(mReadData);
                                memcpy(data, mReadData, data_offset);
                                delete[] mReadData;
+                                mReadData = NULL;
+                        }
+                        else
+                        {
+                                // Offset bigger than the header record. That means we haven't read anything yet.
+                                data_offset = 0;
+                                file_offset = mOffset - TEXTURE_CACHE_ENTRY_SIZE;
+                                file_size = mDataSize;
+                                // No data from header cache to copy in that case, we skipped it all
                        }
+                        // Now use that buffer as the object read buffer
+                        llassert_always(mReadData == NULL);
                        mReadData = data;
-                        bytes_read = LLAPRFile::readEx(filename, 
+                        // Read the data at last
+                        S32 bytes_read = LLAPRFile::readEx(filename, 
                                                                                         mReadData + data_offset,
                                                                                         file_offset, file_size);
                        if (bytes_read != file_size)
                        {
-//                              llwarns << "LLTextureCacheWorker: "  << mID
+                                llwarns << "LLTextureCacheWorker: "  << mID
-//                                              << " incorrect number of bytes read from body: " << bytes_read
+                                                << " incorrect number of bytes read from body: " << bytes_read
-//                                              << " / " << file_size << llendl;
+                                                << " / " << file_size << llendl;
+                                delete[] mReadData;
+                                mReadData = NULL;
                                mDataSize = -1; // failed
-                                return true;
+                                done = true;
                        }
                }
                else
                {
-                        mDataSize = TEXTURE_CACHE_ENTRY_SIZE;
+                        // No body, we're done.
-                }
+                        mDataSize = llmax(TEXTURE_CACHE_ENTRY_SIZE - mOffset, 0);
-                
+                        lldebugs << "No body file for: " << filename << llendl;
-                return true;
+                }       
-#endif
+                // Nothing else to do at that point...
+                done = true;
        }
-        
-        return false;
+        // Clean up and exit
+        return done;
 }
+// This is where *everything* about a texture is written down in the cache system (entry map, header and body)
+// Current assumption are:
+// - the whole data are in a raw form, starting at mWriteData
+// - the size of this raw data is mDataSize and can be smaller than TEXTURE_CACHE_ENTRY_SIZE (the size of a record in the header cache)
+// - the code *does not* support offset writing so there are no difference between buffer addresses and start of data
 bool LLTextureCacheRemoteWorker::doWrite()
 {
+        bool done = false;
        S32 idx = -1;
-        // No LOCAL state for write()
+        // First state / stage : check that what we're trying to cache is in an OK shape
-        
        if (mState == INIT)
        {
+                llassert_always(mOffset == 0);  // We currently do not support write offsets
+                llassert_always(mDataSize > 0); // Things will go badly wrong if mDataSize is nul or negative...
+                mState = CACHE;
+        }
+        
+        // No LOCAL state for write(): because it doesn't make much sense to cache a local file...
+        // Second state / stage : set an entry in the headers entry (texture.entries) file
+        if (!done && (mState == CACHE))
+        {
+                bool alreadyCached = false;
                S32 cur_imagesize = 0;
-                S32 offset = mOffset;
+                // Checks if this image is already in the entry list
-                idx = mCache->getHeaderCacheEntry(mID, false, &cur_imagesize);
+                idx = mCache->getHeaderCacheEntry(mID, cur_imagesize);
-                if (idx >= 0 && cur_imagesize > 0)
+                if (idx >= 0 && (cur_imagesize >= 0))
                {
-                        offset = TEXTURE_CACHE_ENTRY_SIZE; // don't re-write header
+                        alreadyCached = true;   // already there and non empty
                }
-                idx = mCache->getHeaderCacheEntry(mID, true, &mImageSize); // touch entry
+                idx = mCache->setHeaderCacheEntry(mID, mImageSize); // create or touch the entry
-                if (idx >= 0)
+                if (idx < 0)
                {
-                        if(cur_imagesize > 0 && mImageSize != cur_imagesize)
+                        llwarns << "LLTextureCacheWorker: "  << mID
-                        {
+                                        << " Unable to create header entry for writing!" << llendl;
-//                              llwarns << "Header cache entry size: " << cur_imagesize << " != mImageSize: " << mImageSize << llendl;
+                        mDataSize = -1; // failed
-                                offset = 0; // re-write header
+                        done = true;
-                        }
-                        mState = offset < TEXTURE_CACHE_ENTRY_SIZE ? HEADER : BODY;
                }
                else
                {
-                        mDataSize = -1; // failed
+                        if (cur_imagesize > 0 && (mImageSize != cur_imagesize))
-                        return true;
+                        {
+                                alreadyCached = false; // re-write the header if the size changed in all cases
+                        }
+                        if (alreadyCached && (mDataSize <= TEXTURE_CACHE_ENTRY_SIZE))
+                        {
+                                // Small texture already cached case: we're done with writing
+                                done = true;
+                        }
+                        else
+                        {
+                                // If the texture has already been cached, we don't resave the header and go directly to the body part
+                                mState = alreadyCached ? BODY : HEADER;
+                        }
                }
        }
-        
-        if (mState == HEADER)
+        // Third stage / state : write the header record in the header file (texture.cache)
+        if (!done && (mState == HEADER))
        {
-#if USE_LFS_WRITE
+                llassert_always(idx >= 0);      // we need an entry here or storing the header makes no sense
-                if (mFileHandle == LLLFSThread::nullHandle())
+                S32 offset = idx * TEXTURE_CACHE_ENTRY_SIZE;    // skip to the correct spot in the header file
+                S32 size = TEXTURE_CACHE_ENTRY_SIZE;                    // record size is fixed for the header
+                S32 bytes_written;
+                if (mDataSize < TEXTURE_CACHE_ENTRY_SIZE)
                {
-                        llassert_always(idx >= 0);
+                        // We need to write a full record in the header cache so, if the amount of data is smaller
-                        llassert_always(mOffset < TEXTURE_CACHE_ENTRY_SIZE);
+                        // than a record, we need to transfer the data to a buffer padded with 0 and write that
-                        S32 offset = idx * TEXTURE_CACHE_ENTRY_SIZE + mOffset;
+                        U8* padBuffer = new U8[TEXTURE_CACHE_ENTRY_SIZE];
-                        S32 size = TEXTURE_CACHE_ENTRY_SIZE - mOffset;
+                        memset(padBuffer, 0, TEXTURE_CACHE_ENTRY_SIZE);         // Init with zeros
-                        mBytesRead = -1;
+                        memcpy(padBuffer, mWriteData, mDataSize);                       // Copy the write buffer
-                        mBytesToRead = size;
+                        bytes_written = LLAPRFile::writeEx(mCache->mHeaderDataFileName, padBuffer, offset, size);
-                        setPriority(LLWorkerThread::PRIORITY_LOW | mPriority);
+                        delete [] padBuffer;
-                        mFileHandle = LLLFSThread::sLocal->write(mCache->mHeaderDataFileName,
-                                                                                                         mWriteData, offset, mBytesToRead,
-                                                                                                         new WriteResponder(mCache, mRequestHandle));
-                        return false;
                }
                else
                {
-                        if (mBytesRead >= 0)
+                        // Write the header record (== first TEXTURE_CACHE_ENTRY_SIZE bytes of the raw file) in the header file
-                        {
+                        bytes_written = LLAPRFile::writeEx(mCache->mHeaderDataFileName, mWriteData, offset, size);
-                                if (mBytesRead != mBytesToRead)
-                                {
-//                                      llwarns << "LLTextureCacheWorker: "  << mID
-//                                                      << " incorrect number of bytes written to header: " << mBytesRead
-//                                                      << " != " << mBytesToRead << llendl;
-                                        mDataSize = -1; // failed
-                                        return true;
-                                }
-                                if (mDataSize <=  mBytesToRead)
-                                {
-                                        return true; // done
-                                }
-                                else
-                                {
-                                        mFileHandle = LLLFSThread::nullHandle();
-                                        mState = BODY;
-                                }
-                        }
-                        else
-                        {
-                                return false;
-                        }
                }
-#else
-                llassert_always(idx >= 0);
-                llassert_always(mOffset < TEXTURE_CACHE_ENTRY_SIZE);
-                S32 offset = idx * TEXTURE_CACHE_ENTRY_SIZE + mOffset;
-                S32 size = TEXTURE_CACHE_ENTRY_SIZE - mOffset;
-                S32 bytes_written = LLAPRFile::writeEx(mCache->mHeaderDataFileName, mWriteData, offset, size);          
                if (bytes_written <= 0)
                {
-//                      llwarns << "LLTextureCacheWorker: missing entry: " << mID << llendl;
+                        llwarns << "LLTextureCacheWorker: "  << mID
+                                        << " Unable to write header entry!" << llendl;
                        mDataSize = -1; // failed
-                        return true;
+                        done = true;
                }
-                if (mDataSize <= size)
+                // If we wrote everything (may be more with padding) in the header cache, 
+                // we're done so we don't have a body to store
+                if (mDataSize <= bytes_written)
                {
-                        return true; // done
+                        done = true;
                }
                else
                {
                        mState = BODY;
                }
-#endif
        }
        
-        if (mState == BODY)
+        // Fourth stage / state : write the body file, i.e. the rest of the texture in a "UUID" file name
+        if (!done && (mState == BODY))
        {
-#if USE_LFS_WRITE
+                llassert(mDataSize > TEXTURE_CACHE_ENTRY_SIZE); // wouldn't make sense to be here otherwise...
-                if (mFileHandle == LLLFSThread::nullHandle())
+                S32 file_size = mDataSize - TEXTURE_CACHE_ENTRY_SIZE;
+                if ((file_size > 0) && mCache->updateTextureEntryList(mID, file_size))
                {
-                        S32 data_offset = TEXTURE_CACHE_ENTRY_SIZE - mOffset;
+                        // build the cache file name from the UUID
-                        data_offset = llmax(data_offset, 0);
+                        std::string filename = mCache->getTextureFileName(mID);                 
-                        S32 file_size = mDataSize - data_offset;
+//                      llinfos << "Writing Body: " << filename << " Bytes: " << file_offset+file_size << llendl;
-                        S32 file_offset = mOffset - TEXTURE_CACHE_ENTRY_SIZE;
+                        S32 bytes_written = LLAPRFile::writeEx( filename, 
-                        file_offset = llmax(file_offset, 0);
+                                                                                                        mWriteData + TEXTURE_CACHE_ENTRY_SIZE,
-                        if (file_size > 0 && mCache->appendToTextureEntryList(mID, file_size))
+                                                                                                        0, file_size);
-                        {
-                                std::string filename = mCache->getTextureFileName(mID);
-                                mBytesRead = -1;
-                                mBytesToRead = file_size;
-                                setPriority(LLWorkerThread::PRIORITY_LOW | mPriority);
-                                mFileHandle = LLLFSThread::sLocal->write(filename,
-                                                                                                                 mWriteData + data_offset, file_offset, mBytesToRead,
-                                                                                                                 new WriteResponder(mCache, mRequestHandle));
-                                return false;
-                        }
-                        else
-                        {
-                                mDataSize = 0; // no data written
-                                return true; // done
-                        }
-                }
-                else
-                {
-                        if (mBytesRead >= 0)
-                        {
-                                if (mBytesRead != mBytesToRead)
-                                {
-//                                      llwarns << "LLTextureCacheWorker: "  << mID
-//                                                      << " incorrect number of bytes written to body: " << mBytesRead
-//                                                      << " != " << mBytesToRead << llendl;
-                                        mDataSize = -1; // failed
-                                }
-                                return true;
-                        }
-                        else
-                        {
-                                return false;
-                        }
-                }
-#else
-                S32 data_offset = TEXTURE_CACHE_ENTRY_SIZE - mOffset;
-                data_offset = llmax(data_offset, 0);
-                S32 file_size = mDataSize - data_offset;
-                S32 file_offset = mOffset - TEXTURE_CACHE_ENTRY_SIZE;
-                file_offset = llmax(file_offset, 0);
-                S32 bytes_written = 0;
-                if (file_size > 0 && mCache->appendToTextureEntryList(mID, file_size))
-                {
-                        std::string filename = mCache->getTextureFileName(mID);
-                        
-                        bytes_written = LLAPRFile::writeEx(filename, 
-                                                                                                 mWriteData + data_offset,
-                                                                                                 file_offset, file_size);
                        if (bytes_written <= 0)
                        {
+                                llwarns << "LLTextureCacheWorker: "  << mID
+                                                << " incorrect number of bytes written to body: " << bytes_written
+                                                << " / " << file_size << llendl;
                                mDataSize = -1; // failed
+                                done = true;
                        }
                }
                else
                {
                        mDataSize = 0; // no data written
                }
+                // Nothing else to do at that point...
-                return true;
+                done = true;
-#endif
        }
-        
-        return false;
+        // Clean up and exit
+        return done;
 }
 //virtual
 bool LLTextureCacheWorker::doWork(S32 param)
 {
-// *TODO reenable disabled apr_pool usage disabled due to maint-render-9 merge breakage -brad
-        //allocate a new local apr_pool
-//      LLAPRPool pool ;
-        //save the current mFileAPRPool to avoid breaking anything.
-//      apr_pool_t* old_pool = mCache->getFileAPRPool() ;
-        //make mFileAPRPool to point to the local one
-//      mCache->setFileAPRPool(pool.getAPRPool()) ;
        bool res = false;
        if (param == 0) // read
        {
@@ -815,10 +673,6 @@ bool LLTextureCacheWorker::doWork(S32 param)
        {
                llassert_always(0);
        }
-        //set mFileAPRPool back, the local one will be released automatically.
-//      mCache->setFileAPRPool(old_pool) ;
        return res;
 }
@@ -884,6 +738,7 @@ LLTextureCache::LLTextureCache(bool threaded)
          mWorkersMutex(NULL),
          mHeaderMutex(NULL),
          mListMutex(NULL),
+          mHeaderAPRFile(NULL),
          mReadOnly(FALSE),
          mTexturesSizeTotal(0),
          mDoPurge(FALSE)
@@ -892,9 +747,6 @@ LLTextureCache::LLTextureCache(bool threaded)
 LLTextureCache::~LLTextureCache()
 {
-        purgeTextureFilesTimeSliced(TRUE); // force-flush all pending file deletes
-        // apr_pool_destroy(mFileAPRPool);
 }
 //////////////////////////////////////////////////////////////////////////////
@@ -926,6 +778,9 @@ S32 LLTextureCache::update(U32 max_time_ms)
                }
        }
+        unlockWorkers(); 
+        
+        // call 'completed' with workers list unlocked (may call readComplete() or writeComplete()
        for (responder_list_t::iterator iter1 = completed_list.begin();
                 iter1 != completed_list.end(); ++iter1)
        {
@@ -934,8 +789,6 @@ S32 LLTextureCache::update(U32 max_time_ms)
                responder->completed(success);
        }
        
-        unlockWorkers();
-        
        return res;
 }
@@ -954,32 +807,48 @@ std::string LLTextureCache::getTextureFileName(const LLUUID& id)
 {
        std::string idstr = id.asString();
        std::string delem = gDirUtilp->getDirDelimiter();
-        std::string filename = mTexturesDirName + delem + idstr[0] + delem + idstr;
+        std::string filename = mTexturesDirName + delem + idstr[0] + delem + idstr + ".texture";
        return filename;
 }
-bool LLTextureCache::appendToTextureEntryList(const LLUUID& id, S32 bodysize)
+bool LLTextureCache::updateTextureEntryList(const LLUUID& id, S32 bodysize)
 {
        bool res = false;
        bool purge = false;
-        // Append UUID to end of texture entries
        {
                LLMutexLock lock(&mHeaderMutex);
-                size_map_t::iterator iter = mTexturesSizeMap.find(id);
+                size_map_t::iterator iter1 = mTexturesSizeMap.find(id);
-                if (iter == mTexturesSizeMap.end() || iter->second < bodysize)
+                if (iter1 == mTexturesSizeMap.end() || iter1->second < bodysize)
                {
                        llassert_always(bodysize > 0);
-                        Entry* entry = new Entry(id, bodysize, time(NULL));
-                        LLAPRFile::writeEx(mTexturesDirEntriesFileName,
+                        S32 oldbodysize = 0;
-                                                                 (U8*)entry, -1, 1*sizeof(Entry));                      
+                        if (iter1 != mTexturesSizeMap.end())
-                        delete entry;
-                        if (iter != mTexturesSizeMap.end())
                        {
-                                mTexturesSizeTotal -= iter->second;
+                                oldbodysize = iter1->second;
                        }
+                                                
+                        Entry entry;
+                        S32 idx = openAndReadEntry(id, entry, false);
+                        if (idx < 0)
+                        {
+                                // TODO: change to llwarns
+                                llerrs << "Failed to open entry: " << id << llendl;
+                                removeFromCache(id);
+                                return false;
+                        }                       
+                        else if (oldbodysize != entry.mBodySize)
+                        {
+                                // TODO: change to llwarns
+                                llerrs << "Entry mismatch in mTextureSizeMap / mHeaderIDMap"
+                                           << " idx=" << idx << " oldsize=" << oldbodysize << " entrysize=" << entry.mBodySize << llendl;
+                        }
+                        entry.mBodySize = bodysize;
+                        writeEntryAndClose(idx, entry);
+                        
+                        mTexturesSizeTotal -= oldbodysize;
                        mTexturesSizeTotal += bodysize;
-                        mTexturesSizeMap[id] = bodysize;
+                        
                        if (mTexturesSizeTotal > sCacheMaxTexturesSize)
                        {
                                purge = true;
@@ -998,7 +867,7 @@ bool LLTextureCache::appendToTextureEntryList(const LLUUID& id, S32 bodysize)
 //static
 const S32 MAX_REASONABLE_FILE_SIZE = 512*1024*1024; // 512 MB
-F32 LLTextureCache::sHeaderCacheVersion = 1.0f;
+F32 LLTextureCache::sHeaderCacheVersion = 1.2f;
 U32 LLTextureCache::sCacheMaxEntries = MAX_REASONABLE_FILE_SIZE / TEXTURE_CACHE_ENTRY_SIZE;
 S64 LLTextureCache::sCacheMaxTexturesSize = 0; // no limit
 const char* entries_filename = "texture.entries";
@@ -1011,7 +880,6 @@ void LLTextureCache::setDirNames(ELLPath location)
        mHeaderEntriesFileName = gDirUtilp->getExpandedFilename(location, entries_filename);
        mHeaderDataFileName = gDirUtilp->getExpandedFilename(location, cache_filename);
        mTexturesDirName = gDirUtilp->getExpandedFilename(location, textures_dirname);
-        mTexturesDirEntriesFileName = mTexturesDirName + delem + entries_filename;
 }
 void LLTextureCache::purgeCache(ELLPath location)
@@ -1019,7 +887,7 @@ void LLTextureCache::purgeCache(ELLPath location)
        if (!mReadOnly)
        {
                setDirNames(location);
-        
+                llassert_always(mHeaderAPRFile == NULL);
                LLAPRFile::remove(mHeaderEntriesFileName);
                LLAPRFile::remove(mHeaderDataFileName);
        }
@@ -1062,80 +930,315 @@ S64 LLTextureCache::initCache(ELLPath location, S64 max_size, BOOL read_only)
        return max_size; // unused cache space
 }
-struct lru_data
+//----------------------------------------------------------------------------
+// mHeaderMutex must be locked for the following functions!
+LLAPRFile* LLTextureCache::openHeaderEntriesFile(bool readonly, S32 offset)
+{
+        llassert_always(mHeaderAPRFile == NULL);
+        apr_int32_t flags = readonly ? APR_READ|APR_BINARY : APR_READ|APR_WRITE|APR_BINARY;
+        mHeaderAPRFile = new LLAPRFile(mHeaderEntriesFileName, flags, LLAPRFile::local);
+        mHeaderAPRFile->seek(APR_SET, offset);
+        return mHeaderAPRFile;
+}
+void LLTextureCache::closeHeaderEntriesFile()
+{
+        llassert_always(mHeaderAPRFile != NULL);
+        delete mHeaderAPRFile;
+        mHeaderAPRFile = NULL;
+}
+void LLTextureCache::readEntriesHeader()
+{
+        // mHeaderEntriesInfo initializes to default values so safe not to read it
+                llassert_always(mHeaderAPRFile == NULL);
+        if (LLAPRFile::isExist(mHeaderEntriesFileName))
+        {
+                LLAPRFile::readEx(mHeaderEntriesFileName, (U8*)&mHeaderEntriesInfo, 0, sizeof(EntriesInfo));
+        }
+}
+void LLTextureCache::writeEntriesHeader()
 {
-        lru_data(U32 t, S32 i, const LLUUID& id) { time=t; index=i; uuid=id; }
+        llassert_always(mHeaderAPRFile == NULL);
-        U32 time;
+        if (!mReadOnly)
-        S32 index;
+        {
-        LLUUID uuid;
+                LLAPRFile::writeEx(mHeaderEntriesFileName, (U8*)&mHeaderEntriesInfo, 0, sizeof(EntriesInfo));
-        struct Compare
+        }
-        {
+}
-                // lhs < rhs
-                typedef const lru_data* lru_data_ptr;
+static S32 mHeaderEntriesMaxWriteIdx = 0;
-                bool operator()(const lru_data_ptr& a, const lru_data_ptr& b) const
+S32 LLTextureCache::openAndReadEntry(const LLUUID& id, Entry& entry, bool create)
+{
+        S32 idx = -1;
+        
+        id_map_t::iterator iter1 = mHeaderIDMap.find(id);
+        if (iter1 != mHeaderIDMap.end())
+        {
+                idx = iter1->second;
+        }
+        if (idx < 0)
+        {
+                if (create && !mReadOnly)
                {
-                        if(a->time == b->time)
+                        if (mHeaderEntriesInfo.mEntries < sCacheMaxEntries)
-                                return (a->index < b->index);
+                        {
+                                // Add an entry to the end of the list
+                                idx = mHeaderEntriesInfo.mEntries++;
+                        }
+                        else if (!mFreeList.empty())
+                        {
+                                idx = *(mFreeList.begin());
+                                mFreeList.erase(mFreeList.begin());
+                        }
                        else
-                                return (a->time >= b->time);
+                        {
+                                // Look for a still valid entry in the LRU
+                                for (std::set<LLUUID>::iterator iter2 = mLRU.begin(); iter2 != mLRU.end();)
+                                {
+                                        std::set<LLUUID>::iterator curiter2 = iter2++;
+                                        LLUUID oldid = *curiter2;
+                                        // Erase entry from LRU regardless
+                                        mLRU.erase(curiter2);
+                                        // Look up entry and use it if it is valid
+                                        id_map_t::iterator iter3 = mHeaderIDMap.find(oldid);
+                                        if (iter3 != mHeaderIDMap.end() && iter3->second >= 0)
+                                        {
+                                                idx = iter3->second;
+                                                mHeaderIDMap.erase(oldid);
+                                                mTexturesSizeMap.erase(oldid);
+                                                break;
+                                        }
+                                }
+                                // if (idx < 0) at this point, we will rebuild the LRU 
+                                //  and retry if called from setHeaderCacheEntry(),
+                                //  otherwise this shouldn't happen and will trigger an error
+                        }
+                        if (idx >= 0)
+                        {
+                                // Set the header index
+                                mHeaderIDMap[id] = idx;
+                                llassert_always(mTexturesSizeMap.erase(id) == 0);
+                                // Initialize the entry (will get written later)
+                                entry.init(id, time(NULL));
+                                // Update Header
+                                writeEntriesHeader();
+                                // Write Entry
+                                S32 offset = sizeof(EntriesInfo) + idx * sizeof(Entry);
+                                LLAPRFile* aprfile = openHeaderEntriesFile(false, offset);
+                                S32 bytes_written = aprfile->write((void*)&entry, (S32)sizeof(Entry));
+                                llassert_always(bytes_written == sizeof(Entry));
+                                mHeaderEntriesMaxWriteIdx = llmax(mHeaderEntriesMaxWriteIdx, idx);
+                                closeHeaderEntriesFile();
+                        }
                }
-        };                              
+        }
-};
+        else
+        {
+                // Remove this entry from the LRU if it exists
+                mLRU.erase(id);
+                // Read the entry
+                S32 offset = sizeof(EntriesInfo) + idx * sizeof(Entry);
+                LLAPRFile* aprfile = openHeaderEntriesFile(true, offset);
+                S32 bytes_read = aprfile->read((void*)&entry, (S32)sizeof(Entry));
+                llassert_always(bytes_read == sizeof(Entry));
+                llassert_always(entry.mImageSize == 0 || entry.mImageSize == -1 || entry.mImageSize > entry.mBodySize);
+                closeHeaderEntriesFile();
+        }
+        return idx;
+}
+void LLTextureCache::writeEntryAndClose(S32 idx, Entry& entry)
+{
+        if (idx >= 0)
+        {
+                if (!mReadOnly)
+                {
+                        entry.mTime = time(NULL);
+                        llassert_always(entry.mImageSize == 0 || entry.mImageSize == -1 || entry.mImageSize > entry.mBodySize);
+                        if (entry.mBodySize > 0)
+                        {
+                                mTexturesSizeMap[entry.mID] = entry.mBodySize;
+                        }
+//                      llinfos << "Updating TE: " << idx << ": " << id << " Size: " << entry.mBodySize << " Time: " << entry.mTime << llendl;
+                        S32 offset = sizeof(EntriesInfo) + idx * sizeof(Entry);
+                        LLAPRFile* aprfile = openHeaderEntriesFile(false, offset);
+                        S32 bytes_written = aprfile->write((void*)&entry, (S32)sizeof(Entry));
+                        llassert_always(bytes_written == sizeof(Entry));
+                        mHeaderEntriesMaxWriteIdx = llmax(mHeaderEntriesMaxWriteIdx, idx);
+                        closeHeaderEntriesFile();
+                }
+        }
+}
+U32 LLTextureCache::openAndReadEntries(std::vector<Entry>& entries)
+{
+        U32 num_entries = mHeaderEntriesInfo.mEntries;
+        mHeaderIDMap.clear();
+        mTexturesSizeMap.clear();
+        mFreeList.clear();
+        mTexturesSizeTotal = 0;
+        LLAPRFile* aprfile = openHeaderEntriesFile(false, (S32)sizeof(EntriesInfo));
+        for (U32 idx=0; idx<num_entries; idx++)
+        {
+                Entry entry;
+                S32 bytes_read = aprfile->read((void*)(&entry), (S32)sizeof(Entry));
+                if (bytes_read < sizeof(Entry))
+                {
+                        llwarns << "Corrupted header entries, failed at " << idx << " / " << num_entries << llendl;
+                        closeHeaderEntriesFile();
+                        purgeAllTextures(false);
+                        return 0;
+                }
+                entries.push_back(entry);
+//              llinfos << "ENTRY: " << entry.mTime << " TEX: " << entry.mID << " IDX: " << idx << " Size: " << entry.mImageSize << llendl;
+                if (entry.mImageSize < 0)
+                {
+                        mFreeList.insert(idx);
+                }
+                else
+                {
+                        mHeaderIDMap[entry.mID] = idx;
+                        if (entry.mBodySize > 0)
+                        {
+                                mTexturesSizeMap[entry.mID] = entry.mBodySize;
+                                mTexturesSizeTotal += entry.mBodySize;
+                        }
+                        llassert_always(entry.mImageSize == 0 || entry.mImageSize > entry.mBodySize);
+                }
+        }
+        closeHeaderEntriesFile();
+        return num_entries;
+}
+void LLTextureCache::writeEntriesAndClose(const std::vector<Entry>& entries)
+{
+        S32 num_entries = entries.size();
+        llassert_always(num_entries == mHeaderEntriesInfo.mEntries);
+        
+        if (!mReadOnly)
+        {
+                LLAPRFile* aprfile = openHeaderEntriesFile(false, (S32)sizeof(EntriesInfo));
+                for (S32 idx=0; idx<num_entries; idx++)
+                {
+                        S32 bytes_written = aprfile->write((void*)(&entries[idx]), (S32)sizeof(Entry));
+                        llassert_always(bytes_written == sizeof(Entry));
+                }
+                mHeaderEntriesMaxWriteIdx = llmax(mHeaderEntriesMaxWriteIdx, num_entries-1);
+                closeHeaderEntriesFile();
+        }
+}
+//----------------------------------------------------------------------------
 // Called from either the main thread or the worker thread
 void LLTextureCache::readHeaderCache()
 {
        LLMutexLock lock(&mHeaderMutex);
-        mHeaderEntriesInfo.mVersion = 0.f;
-        mHeaderEntriesInfo.mEntries = 0;
+        mLRU.clear(); // always clear the LRU
-        if (LLAPRFile::isExist(mHeaderEntriesFileName))
-        {
+        readEntriesHeader();
-                LLAPRFile::readEx(mHeaderEntriesFileName,
+        
-                                                        (U8*)&mHeaderEntriesInfo, 0, sizeof(EntriesInfo));
-        }
        if (mHeaderEntriesInfo.mVersion != sHeaderCacheVersion)
        {
                if (!mReadOnly)
                {
-                        // Info with 0 entries
+                        purgeAllTextures(false);
-                        mHeaderEntriesInfo.mVersion = sHeaderCacheVersion;
-                        LLAPRFile::writeEx(mHeaderEntriesFileName, 
-                                                                 (U8*)&mHeaderEntriesInfo, 0, sizeof(EntriesInfo));
                }
        }
        else
        {
-                S32 num_entries = mHeaderEntriesInfo.mEntries;
+                std::vector<Entry> entries;
+                U32 num_entries = openAndReadEntries(entries);
                if (num_entries)
                {
-                        Entry* entries = new Entry[num_entries];
+                        U32 empty_entries = 0;
+                        typedef std::pair<U32, LLUUID> lru_data_t;
+                        std::set<lru_data_t> lru;
+                        std::vector<LLUUID> purge_list;
+                        for (U32 i=0; i<num_entries; i++)
                        {
-                                LLAPRFile::readEx(mHeaderEntriesFileName, 
+                                Entry& entry = entries[i];
-                                                                (U8*)entries, sizeof(EntriesInfo), num_entries*sizeof(Entry));
+                                const LLUUID& id = entry.mID;
+                                if (entry.mImageSize < 0)
+                                {
+                                        // This will be in the Free List, don't put it in the LRY
+                                        ++empty_entries;
+                                }
+                                else
+                                {
+                                        lru.insert(std::make_pair(entry.mTime, id));
+                                        if (entry.mBodySize > 0)
+                                        {
+                                                if (entry.mBodySize > entry.mImageSize)
+                                                {
+                                                        // Shouldn't happen, failsafe only
+                                                        llwarns << "Bad entry: " << i << ": " << id << ": BodySize: " << entry.mBodySize << llendl;
+                                                        purge_list.push_back(id);
+                                                }
+                                        }
+                                }
                        }
-                        typedef std::set<lru_data*, lru_data::Compare> lru_set_t;
+                        if (num_entries > sCacheMaxEntries)
-                        lru_set_t lru;
-                        for (S32 i=0; i<num_entries; i++)
                        {
-                                if (entries[i].mSize >= 0) // -1 indicates erased entry, skip
+                                // Special case: cache size was reduced, need to remove entries
+                                // Note: After we prune entries, we will call this again and create the LRU
+                                U32 entries_to_purge = (num_entries-empty_entries) - sCacheMaxEntries;
+                                if (entries_to_purge > 0)
                                {
-                                        const LLUUID& id = entries[i].mID;
+                                        for (std::set<lru_data_t>::iterator iter = lru.begin(); iter != lru.end(); ++iter)
-                                        lru.insert(new lru_data(entries[i].mTime, i, id));
+                                        {
-                                        mHeaderIDMap[id] = i;
+                                                purge_list.push_back(iter->second);
+                                                if (--entries_to_purge <= 0)
+                                                        break;
+                                        }
                                }
                        }
-                        mLRU.clear();
+                        else
-                        S32 lru_entries = sCacheMaxEntries / 10;
-                        for (lru_set_t::iterator iter = lru.begin(); iter != lru.end(); ++iter)
                        {
-                                lru_data* data = *iter;
+                                S32 lru_entries = (S32)((F32)sCacheMaxEntries * TEXTURE_CACHE_LRU_SIZE);
-                                mLRU[data->index] = data->uuid;
+                                for (std::set<lru_data_t>::iterator iter = lru.begin(); iter != lru.end(); ++iter)
-                                if (--lru_entries <= 0)
+                                {
-                                        break;
+                                        mLRU.insert(iter->second);
+//                                      llinfos << "LRU: " << iter->first << " : " << iter->second << llendl;
+                                        if (--lru_entries <= 0)
+                                                break;
+                                }
+                        }
+                        
+                        if (purge_list.size() > 0)
+                        {
+                                for (std::vector<LLUUID>::iterator iter = purge_list.begin(); iter != purge_list.end(); ++iter)
+                                {
+                                        removeFromCache(*iter);
+                                }
+                                // If we removed any entries, we need to rebuild the entries list,
+                                // write the header, and call this again
+                                std::vector<Entry> new_entries;
+                                for (U32 i=0; i<num_entries; i++)
+                                {
+                                        const Entry& entry = entries[i];
+                                        if (entry.mImageSize >=0)
+                                        {
+                                                new_entries.push_back(entry);
+                                        }
+                                }
+                                llassert_always(new_entries.size() <= sCacheMaxEntries);
+                                mHeaderEntriesInfo.mEntries = new_entries.size();
+                                writeEntriesAndClose(new_entries);
+                                readHeaderCache(); // repeat with new entries file
+                        }
+                        else
+                        {
+                                writeEntriesAndClose(entries);
                        }
-                        for_each(lru.begin(), lru.end(), DeletePointer());
-                        delete[] entries;
                }
        }
 }
@@ -1158,13 +1261,21 @@ void LLTextureCache::purgeAllTextures(bool purge_directories)
                                LLFile::rmdir(dirname);
                        }
                }
-                LLAPRFile::remove(mTexturesDirEntriesFileName);
                if (purge_directories)
                {
                        LLFile::rmdir(mTexturesDirName);
                }
        }
+        mHeaderIDMap.clear();
        mTexturesSizeMap.clear();
+        mTexturesSizeTotal = 0;
+        mFreeList.clear();
+        mTexturesSizeTotal = 0;
+        // Info with 0 entries
+        mHeaderEntriesInfo.mVersion = sHeaderCacheVersion;
+        mHeaderEntriesInfo.mEntries = 0;
+        writeEntriesHeader();
 }
 void LLTextureCache::purgeTextures(bool validate)
@@ -1178,50 +1289,37 @@ void LLTextureCache::purgeTextures(bool validate)
        LLAppViewer::instance()->pauseMainloopTimeout();
        LLMutexLock lock(&mHeaderMutex);
-        
-        S32 filesize = LLAPRFile::size(mTexturesDirEntriesFileName);
+        llinfos << "TEXTURE CACHE: Purging." << llendl;
-        S32 num_entries = filesize / sizeof(Entry);
-        if (num_entries * (S32)sizeof(Entry) != filesize)
+        // Read the entries list
-        {
+        std::vector<Entry> entries;
-                LL_WARNS("TextureCache") << "Bad cache file: " << mTexturesDirEntriesFileName << " Purging." << LL_ENDL;
+        U32 num_entries = openAndReadEntries(entries);
-                purgeAllTextures(false);
+        if (!num_entries)
-                return;
-        }
-        if (num_entries == 0)
        {
-                return; // nothing to do
+                writeEntriesAndClose(entries);
+                return; // nothing to purge
        }
        
-        Entry* entries = new Entry[num_entries];
+        // Use mTexturesSizeMap to collect UUIDs of textures with bodies
-        S32 bytes_read = LLAPRFile::readEx(mTexturesDirEntriesFileName, 
+        typedef std::set<std::pair<U32,S32> > time_idx_set_t;
-                                                                                 (U8*)entries, 0, num_entries*sizeof(Entry));   
+        std::set<std::pair<U32,S32> > time_idx_set;
-        if (bytes_read != filesize)
+        for (size_map_t::iterator iter1 = mTexturesSizeMap.begin();
+                 iter1 != mTexturesSizeMap.end(); ++iter1)
        {
-                LL_WARNS("TextureCache") << "Bad cache file (2): " << mTexturesDirEntriesFileName << " Purging." << LL_ENDL;
+                if (iter1->second > 0)
-                purgeAllTextures(false);
-                return;
-        }
-        
-        LL_DEBUGS("TextureCache") << "TEXTURE CACHE: Reading " << num_entries << " Entries from " << mTexturesDirEntriesFileName << LL_ENDL;
-        
-        std::map<LLUUID, S32> entry_idx_map;
-        S64 total_size = 0;
-        for (S32 idx=0; idx<num_entries; idx++)
-        {
-                const LLUUID& id = entries[idx].mID;
-                LL_DEBUGS("TextureCache") << "Entry: " << id << " Size: " << entries[idx].mSize << " Time: " << entries[idx].mTime << LL_ENDL;
-                std::map<LLUUID, S32>::iterator iter = entry_idx_map.find(id);
-                if (iter != entry_idx_map.end())
                {
-                        // Newer entry replacing older entry
+                        id_map_t::iterator iter2 = mHeaderIDMap.find(iter1->first);
-                        S32 pidx = iter->second;
+                        if (iter2 != mHeaderIDMap.end())
-                        total_size -= entries[pidx].mSize;
+                        {
-                        entries[pidx].mSize = 0; // flag: skip older entry
+                                S32 idx = iter2->second;
+                                time_idx_set.insert(std::make_pair(entries[idx].mTime, idx));
+//                              llinfos << "TIME: " << entries[idx].mTime << " TEX: " << entries[idx].mID << " IDX: " << idx << " Size: " << entries[idx].mImageSize << llendl;
+                        }
                }
-                entry_idx_map[id] = idx;
-                total_size += entries[idx].mSize;
        }
+        
+        // Validate 1/256th of the files on startup
        U32 validate_idx = 0;
        if (validate)
        {
@@ -1230,19 +1328,17 @@ void LLTextureCache::purgeTextures(bool validate)
                gSavedSettings.setU32("CacheValidateCounter", next_idx);
                LL_DEBUGS("TextureCache") << "TEXTURE CACHE: Validating: " << validate_idx << LL_ENDL;
        }
-        
-        S64 min_cache_size = sCacheMaxTexturesSize / 100 * 95;
+        S64 cache_size = mTexturesSizeTotal;
+        S64 purged_cache_size = (sCacheMaxTexturesSize * (S64)((1.f-TEXTURE_CACHE_PURGE_AMOUNT)*100)) / 100;
        S32 purge_count = 0;
-        S32 next_idx = 0;
+        for (time_idx_set_t::iterator iter = time_idx_set.begin();
-        for (S32 idx=0; idx<num_entries; idx++)
+                 iter != time_idx_set.end(); ++iter)
        {
-                if (entries[idx].mSize == 0)
+                S32 idx = iter->second;
-                {
-                        continue;
-                }
                bool purge_entry = false;
                std::string filename = getTextureFileName(entries[idx].mID);
-                if (total_size >= min_cache_size)
+                if (cache_size >= purged_cache_size)
                {
                        purge_entry = true;
                }
@@ -1252,112 +1348,47 @@ void LLTextureCache::purgeTextures(bool validate)
                        S32 uuididx = entries[idx].mID.mData[0];
                        if (uuididx == validate_idx)
                        {
-                                LL_DEBUGS("TextureCache") << "Validating: " << filename << "Size: " << entries[idx].mSize << LL_ENDL;
+                                LL_DEBUGS("TextureCache") << "Validating: " << filename << "Size: " << entries[idx].mBodySize << LL_ENDL;
                                S32 bodysize = LLAPRFile::size(filename);
-                                if (bodysize != entries[idx].mSize)
+                                if (bodysize != entries[idx].mBodySize)
                                {
-                                        LL_WARNS("TextureCache") << "TEXTURE CACHE BODY HAS BAD SIZE: " << bodysize << " != " << entries[idx].mSize
+                                        LL_WARNS("TextureCache") << "TEXTURE CACHE BODY HAS BAD SIZE: " << bodysize << " != " << entries[idx].mBodySize
                                                        << filename << LL_ENDL;
                                        purge_entry = true;
                                }
                        }
                }
-                if (purge_entry)
+                else
                {
-                        purge_count++;
+                        break;
-                        LL_DEBUGS("TextureCache") << "PURGING: " << filename << LL_ENDL;
-                        mFilesToDelete.push_back(filename);
-                        total_size -= entries[idx].mSize;
-                        entries[idx].mSize = 0;
                }
-                else
+                
+                if (purge_entry)
                {
-                        if (next_idx != idx)
+                        purge_count++;
-                        {
+                        LL_DEBUGS("TextureCache") << "PURGING: " << filename << LL_ENDL;
-                                entries[next_idx] = entries[idx];
+                        LLAPRFile::remove(filename);
-                        }
+                        cache_size -= entries[idx].mBodySize;
-                        ++next_idx;
+                        mTexturesSizeTotal -= entries[idx].mBodySize;
+                        entries[idx].mBodySize = 0;
+                        mTexturesSizeMap.erase(entries[idx].mID);
                }
        }
-        num_entries = next_idx;
-        mTimeLastFileDelete.reset();
+        LL_DEBUGS("TextureCache") << "TEXTURE CACHE: Writing Entries: " << num_entries << LL_ENDL;
-        LL_DEBUGS("TextureCache") << "TEXTURE CACHE: Writing Entries: " 
+        writeEntriesAndClose(entries);
-                << num_entries << " (" << num_entries*sizeof(Entry)/1024 << "KB)"
-                << LL_ENDL;
-        
-        LLAPRFile::remove(mTexturesDirEntriesFileName);
-        LLAPRFile::writeEx(mTexturesDirEntriesFileName, 
-                                                 (U8*)&entries[0], 0, num_entries*sizeof(Entry));
-        
-        mTexturesSizeTotal = 0;
-        mTexturesSizeMap.clear();
-        for (S32 idx=0; idx<num_entries; idx++)
-        {
-                mTexturesSizeMap[entries[idx].mID] = entries[idx].mSize;
-                mTexturesSizeTotal += entries[idx].mSize;
-        }
-        llassert(mTexturesSizeTotal == total_size);
        
-        delete[] entries;
        // *FIX:Mani - watchdog back on.
        LLAppViewer::instance()->resumeMainloopTimeout();
        
        LL_INFOS("TextureCache") << "TEXTURE CACHE:"
                        << " PURGED: " << purge_count
                        << " ENTRIES: " << num_entries
-                        << " CACHE SIZE: " << total_size/1024/1024 << " MB"
+                        << " CACHE SIZE: " << mTexturesSizeTotal / 1024*1024 << " MB"
                        << llendl;
 }
-void LLTextureCache::purgeTextureFilesTimeSliced(BOOL force_all)
-{
-        LLMutexLock lock(&mHeaderMutex);
-        F32 delay_between_passes = 1.0f; // seconds
-        F32 max_time_per_pass = 0.1f; // seconds
-        if (!force_all && mTimeLastFileDelete.getElapsedTimeF32() <= delay_between_passes) 
-        {
-                return;
-        }
-        LLTimer timer;
-        S32 howmany = 0;
-        if (mFilesToDelete.size() > 0)
-        {
-                llinfos << "TEXTURE CACHE: " << mFilesToDelete.size() << " files scheduled for deletion" << llendl;
-        }
-        for (LLTextureCache::filename_list_t::iterator iter = mFilesToDelete.begin(); iter!=mFilesToDelete.end(); ) 
-        {       
-                LLTextureCache::filename_list_t::iterator iter2 = iter++;
-                LLAPRFile::remove(*iter2);
-                mFilesToDelete.erase(iter2);
-                howmany++;
-                if (!force_all && timer.getElapsedTimeF32() > max_time_per_pass) 
-                {
-                        break;
-                }
-        }
-        if (!mFilesToDelete.empty())
-        {
-                llinfos << "TEXTURE CACHE: "<< howmany << " files deleted (" 
-                                << mFilesToDelete.size() << " files left for next pass)" 
-                                << llendl;
-        }
-        mTimeLastFileDelete.reset();
-}
 //////////////////////////////////////////////////////////////////////////////
 // call lockWorkers() first!
@@ -1384,75 +1415,39 @@ LLTextureCacheWorker* LLTextureCache::getWriter(handle_t handle)
 }
 //////////////////////////////////////////////////////////////////////////////
 // Called from work thread
-S32 LLTextureCache::getHeaderCacheEntry(const LLUUID& id, bool touch, S32* imagesize)
-{
-        bool retry = false;
-        S32 idx = -1;
+// Reads imagesize from the header, updates timestamp
+S32 LLTextureCache::getHeaderCacheEntry(const LLUUID& id, S32& imagesize)
+{
+        LLMutexLock lock(&mHeaderMutex);
+        Entry entry;
+        S32 idx = openAndReadEntry(id, entry, false);
+        if (idx >= 0)
        {
-                LLMutexLock lock(&mHeaderMutex);
+                imagesize = entry.mImageSize;
-                id_map_t::iterator iter = mHeaderIDMap.find(id);
+                writeEntryAndClose(idx, entry); // updates time
-                if (iter != mHeaderIDMap.end())
+        }
-                {
+        return idx;
-                        idx = iter->second;
+}
-                }
-                else if (touch && !mReadOnly)
-                {
-                        if (mHeaderEntriesInfo.mEntries < sCacheMaxEntries)
-                        {
-                                // Add an entry
-                                idx = mHeaderEntriesInfo.mEntries++;
-                                mHeaderIDMap[id] = idx;
-                                // Update Info
-                                LLAPRFile::writeEx(mHeaderEntriesFileName, 
-                                                                        (U8*)&mHeaderEntriesInfo, 0, sizeof(EntriesInfo));
-                        }
-                        else if (!mLRU.empty())
-                        {
-                                idx = mLRU.begin()->first; // will be erased below
-                                const LLUUID& oldid = mLRU.begin()->second;
-                                mHeaderIDMap.erase(oldid);
-                                mTexturesSizeMap.erase(oldid);
-                                mHeaderIDMap[id] = idx;
-                        }
-                        else
-                        {
-                                idx = -1;
-                                retry = true;
-                        }
-                }
-                if (idx >= 0)
-                {
-                        if (touch && !mReadOnly)
-                        {
-                                // Update the lru entry
-                                mLRU.erase(idx);
-                                llassert_always(imagesize && *imagesize > 0);
-                                Entry* entry = new Entry(id, *imagesize, time(NULL));
-                                S32 offset = sizeof(EntriesInfo) + idx * sizeof(Entry);
-                                LLAPRFile::writeEx(mHeaderEntriesFileName, 
-                                                                         (U8*)entry, offset, sizeof(Entry));
-                                delete entry;
-                        }
-                        else if (imagesize)
-                        {
-                                // Get the image size
-                                Entry entry;
-                                S32 offset = sizeof(EntriesInfo) + idx * sizeof(Entry);
-                                LLAPRFile::readEx(mHeaderEntriesFileName, 
+// Writes imagesize to the header, updates timestamp
-                                                                        (U8*)&entry, offset, sizeof(Entry));
+S32 LLTextureCache::setHeaderCacheEntry(const LLUUID& id, S32 imagesize)
-                                *imagesize = entry.mSize;
+{
-                        }
+        LLMutexLock lock(&mHeaderMutex);
-                }
+        llassert_always(imagesize >= 0);
+        Entry entry;
+        S32 idx = openAndReadEntry(id, entry, true);
+        if (idx >= 0)
+        {
+                entry.mImageSize = imagesize;
+                writeEntryAndClose(idx, entry);
        }
-        if (retry)
+        else // retry
        {
-                readHeaderCache(); // updates the lru
+                readHeaderCache(); // We couldn't write an entry, so refresh the LRU
                llassert_always(!mLRU.empty() || mHeaderEntriesInfo.mEntries < sCacheMaxEntries);
-                idx = getHeaderCacheEntry(id, touch, imagesize); // assert above ensures no inf. recursion
+                idx = setHeaderCacheEntry(id, imagesize); // assert above ensures no inf. recursion
        }
        return idx;
 }
@@ -1468,8 +1463,8 @@ LLTextureCache::handle_t LLTextureCache::readFromCache(const std::string& filena
        //  so let the thread handle it
        LLMutexLock lock(&mWorkersMutex);
        LLTextureCacheWorker* worker = new LLTextureCacheLocalFileWorker(this, priority, filename, id,
-                                                                                                                        NULL, size, offset, 0,
+                                                                                                                                         NULL, size, offset, 0,
-                                                                                                                        responder);
+                                                                                                                                         responder);
        handle_t handle = worker->read();
        mReaders[handle] = worker;
        return handle;
@@ -1482,8 +1477,8 @@ LLTextureCache::handle_t LLTextureCache::readFromCache(const LLUUID& id, U32 pri
        //  so let the thread handle it
        LLMutexLock lock(&mWorkersMutex);
        LLTextureCacheWorker* worker = new LLTextureCacheRemoteWorker(this, priority, id,
-                                                                                                                        NULL, size, offset, 0,
+                                                                                                                                  NULL, size, offset,
-                                                                                                                        responder);
+                                                                                                                                  0, responder);
        handle_t handle = worker->read();
        mReaders[handle] = worker;
        return handle;
@@ -1494,7 +1489,7 @@ bool LLTextureCache::readComplete(handle_t handle, bool abort)
 {
        lockWorkers();
        handle_map_t::iterator iter = mReaders.find(handle);
-        llassert_always(iter != mReaders.end());
+        llassert_always(iter != mReaders.end() || abort);
        LLTextureCacheWorker* worker = iter->second;
        bool res = worker->complete();
        if (res || abort)
@@ -1528,14 +1523,10 @@ LLTextureCache::handle_t LLTextureCache::writeToCache(const LLUUID& id, U32 prio
                purgeTextures(false);
                mDoPurge = FALSE;
        }
-        purgeTextureFilesTimeSliced();  // purge textures from cache in a non-hiccup-way
        LLMutexLock lock(&mWorkersMutex);
        LLTextureCacheWorker* worker = new LLTextureCacheRemoteWorker(this, priority, id,
-                                                                                                                                          data, datasize, 0,
+                                                                                                                                  data, datasize, 0,
-                                                                                                                                          imagesize, responder);
+                                                                                                                                  imagesize, responder);
        handle_t handle = worker->write();
        mWriters[handle] = worker;
        return handle;
@@ -1581,24 +1572,17 @@ void LLTextureCache::addCompleted(Responder* responder, bool success)
 bool LLTextureCache::removeHeaderCacheEntry(const LLUUID& id)
 {
-        if (mReadOnly)
+        if (!mReadOnly)
-        {
-                return false;
-        }
-        LLMutexLock lock(&mHeaderMutex);
-        id_map_t::iterator iter = mHeaderIDMap.find(id);
-        if (iter != mHeaderIDMap.end())
        {
-                S32 idx = iter->second;
+                LLMutexLock lock(&mHeaderMutex);
+                Entry entry;
+                S32 idx = openAndReadEntry(id, entry, false);
                if (idx >= 0)
                {
-                        Entry* entry = new Entry(id, -1, time(NULL));
+                        entry.mImageSize = -1;
-                        S32 offset = sizeof(EntriesInfo) + idx * sizeof(Entry);
+                        entry.mBodySize = 0;
+                        writeEntryAndClose(idx, entry);
-                        LLAPRFile::writeEx(mHeaderEntriesFileName,
+                        mFreeList.insert(idx);
-                                                                 (U8*)entry, offset, sizeof(Entry));
-                        delete entry;
-                        mLRU[idx] = id;
                        mHeaderIDMap.erase(id);
                        mTexturesSizeMap.erase(id);
                        return true;
diff --git a/linden/indra/newview/lltexturecache.h b/linden/indra/newview/lltexturecache.h
index 1e3ed5b..e4f6934 100644
--- a/linden/indra/newview/lltexturecache.h
+++ b/linden/indra/newview/lltexturecache.h
@@ -48,6 +48,27 @@ class LLTextureCache : public LLWorkerThread
        friend class LLTextureCacheRemoteWorker;
        friend class LLTextureCacheLocalFileWorker;
+private:
+        // Entries
+        struct EntriesInfo
+        {
+                EntriesInfo() : mVersion(0.f), mEntries(0) {}
+                F32 mVersion;
+                U32 mEntries;
+        };
+        struct Entry
+        {
+                Entry() {}
+                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; }
+                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
+        };
+        
 public:
        class Responder : public LLResponder
@@ -106,10 +127,14 @@ public:
        // debug
        S32 getNumReads() { return mReaders.size(); }
        S32 getNumWrites() { return mWriters.size(); }
+        S64 getUsage() { return mTexturesSizeTotal; }
+        S64 getMaxUsage() { return sCacheMaxTexturesSize; }
+        U32 getEntries() { return mHeaderEntriesInfo.mEntries; }
+        U32 getMaxEntries() { return sCacheMaxEntries; };
 protected:
        // Accessed by LLTextureCacheWorker
-        bool appendToTextureEntryList(const LLUUID& id, S32 size);
+        bool updateTextureEntryList(const LLUUID& id, S32 size);
        std::string getLocalFileName(const LLUUID& id);
        std::string getTextureFileName(const LLUUID& id);
        void addCompleted(Responder* responder, bool success);
@@ -122,8 +147,16 @@ private:
        void readHeaderCache();
        void purgeAllTextures(bool purge_directories);
        void purgeTextures(bool validate);
-        void purgeTextureFilesTimeSliced(BOOL force_all = FALSE);
+        LLAPRFile* openHeaderEntriesFile(bool readonly, S32 offset);
-        S32 getHeaderCacheEntry(const LLUUID& id, bool touch, S32* imagesize = NULL);
+        void closeHeaderEntriesFile();
+        void readEntriesHeader();
+        void writeEntriesHeader();
+        S32 openAndReadEntry(const LLUUID& id, Entry& entry, bool create);
+        void writeEntryAndClose(S32 idx, Entry& entry);
+        U32 openAndReadEntries(std::vector<Entry>& entries);
+        void writeEntriesAndClose(const std::vector<Entry>& entries);
+        S32 getHeaderCacheEntry(const LLUUID& id, S32& imagesize);
+        S32 setHeaderCacheEntry(const LLUUID& id, S32 imagesize);
        bool removeHeaderCacheEntry(const LLUUID& id);
        void lockHeaders() { mHeaderMutex.lock(); }
        void unlockHeaders() { mHeaderMutex.unlock(); }
@@ -133,6 +166,7 @@ private:
        LLMutex mWorkersMutex;
        LLMutex mHeaderMutex;
        LLMutex mListMutex;
+        LLAPRFile* mHeaderAPRFile;
        
        typedef std::map<handle_t, LLTextureCacheWorker*> handle_map_t;
        handle_map_t mReaders;
@@ -143,49 +177,31 @@ private:
        typedef std::vector<std::pair<LLPointer<Responder>, bool> > responder_list_t;
        responder_list_t mCompletedList;
-        typedef std::list<std::string> filename_list_t;
-        filename_list_t mFilesToDelete;
-        LLTimer mTimeLastFileDelete;
        
        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;
+        std::set<S32> mFreeList; // deleted entries
-        index_map_t mLRU; // index, id; stored as a map for fast removal
+        std::set<LLUUID> mLRU;
        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;
 };
+extern const S32 TEXTURE_CACHE_ENTRY_SIZE;
 #endif // LL_LLTEXTURECACHE_H
diff --git a/linden/indra/newview/lltexturectrl.cpp b/linden/indra/newview/lltexturectrl.cpp
index 5500973..f4476fb 100644
--- a/linden/indra/newview/lltexturectrl.cpp
+++ b/linden/indra/newview/lltexturectrl.cpp
@@ -556,12 +556,12 @@ void LLFloaterTexturePicker::draw()
                if(mImageAssetID.notNull())
                {
                        mTexturep = gImageList.getImage(mImageAssetID, MIPMAP_YES, IMMEDIATE_NO);
-                        mTexturep->setBoostLevel(LLViewerImage::BOOST_PREVIEW);
+                        mTexturep->setBoostLevel(LLViewerImageBoostLevel::BOOST_PREVIEW);
                }
                else if (!mFallbackImageName.empty())
                {
                        mTexturep = gImageList.getImageFromFile(mFallbackImageName);
-                        mTexturep->setBoostLevel(LLViewerImage::BOOST_PREVIEW);
+                        mTexturep->setBoostLevel(LLViewerImageBoostLevel::BOOST_PREVIEW);
                }
                if (mTentativeLabel)
@@ -1314,13 +1314,13 @@ void LLTextureCtrl::draw()
        else if (!mImageAssetID.isNull())
        {
                mTexturep = gImageList.getImage(mImageAssetID, MIPMAP_YES, IMMEDIATE_NO);
-                mTexturep->setBoostLevel(LLViewerImage::BOOST_PREVIEW);
+                mTexturep->setBoostLevel(LLViewerImageBoostLevel::BOOST_PREVIEW);
        }
        else if (!mFallbackImageName.empty())
        {
                // Show fallback image.
                mTexturep = gImageList.getImageFromFile(mFallbackImageName);
-                mTexturep->setBoostLevel(LLViewerImage::BOOST_PREVIEW);
+                mTexturep->setBoostLevel(LLViewerImageBoostLevel::BOOST_PREVIEW);
        }
        
        // Border
diff --git a/linden/indra/newview/lltexturefetch.cpp b/linden/indra/newview/lltexturefetch.cpp
index e9dd792..935b8cc 100644
--- a/linden/indra/newview/lltexturefetch.cpp
+++ b/linden/indra/newview/lltexturefetch.cpp
@@ -32,108 +32,35 @@
 #include "llviewerprecompiledheaders.h"
+#include <iostream>
 #include "llstl.h"
 #include "lltexturefetch.h"
 #include "llcurl.h"
+#include "lldir.h"
 #include "llhttpclient.h"
+#include "llhttpstatuscodes.h"
 #include "llimage.h"
 #include "llimageworker.h"
 #include "llworkerthread.h"
 #include "llagent.h"
 #include "lltexturecache.h"
+#include "llviewercontrol.h"
 #include "llviewerimagelist.h"
 #include "llviewerimage.h"
 #include "llviewerregion.h"
+#include "llworld.h"
 //////////////////////////////////////////////////////////////////////////////
-//static
 class LLTextureFetchWorker : public LLWorkerClass
 {
-friend class LLTextureFetch;
+        friend class LLTextureFetch;
+        friend class HTTPGetResponder;
-private:
-#if 0
-        class URLResponder : public LLHTTPClient::Responder
-        {
-        public:
-                URLResponder(LLTextureFetch* fetcher, const LLUUID& id)
-                        : mFetcher(fetcher), mID(id)
-                {
-                }
-                ~URLResponder()
-                {
-                }
-                virtual void error(U32 status, const std::string& reason)
-                {
-                        mFetcher->lockQueue();
-                        LLTextureFetchWorker* worker = mFetcher->getWorker(mID);
-                        if (worker)
-                        {
-//                              llwarns << "LLTextureFetchWorker::URLResponder::error " << status << ": " << reason << llendl;
-                                worker->callbackURLReceived(LLSD(), false);
-                        }
-                        mFetcher->unlockQueue();
-                }
-                virtual void result(const LLSD& content)
-                {
-                        mFetcher->lockQueue();
-                        LLTextureFetchWorker* worker = mFetcher->getWorker(mID);
-                        if (worker)
-                        {
-                                worker->callbackURLReceived(content, true);
-                        }
-                        mFetcher->unlockQueue();
-                }
-        private:
-                LLTextureFetch* mFetcher;
-                LLUUID mID;
-        };
-        class HTTPGetResponder : public LLHTTPClient::Responder
-        {
-        public:
-                HTTPGetResponder(LLTextureFetch* fetcher, const LLUUID& id)
-                        : mFetcher(fetcher), mID(id)
-                {
-                }
-                ~HTTPGetResponder()
-                {
-                }
-                virtual void completed(U32 status, const std::stringstream& content)
-                {
-                        mFetcher->lockQueue();
-                        LLTextureFetchWorker* worker = mFetcher->getWorker(mID);
-                        if (worker)
-                        {
-                                const std::string& cstr = content.str();
-                                if (200 <= status &&  status < 300)
-                                {
-                                        if (203 == status) // partial information (i.e. last block)
-                                        {
-                                                worker->callbackHttpGet((U8*)cstr.c_str(), cstr.length(), true);
-                                        }
-                                        else
-                                        {
-                                                worker->callbackHttpGet((U8*)cstr.c_str(), cstr.length(), false);
-                                        }
-                                }
-                                else
-                                {
-//                                      llinfos << "LLTextureFetchWorker::HTTPGetResponder::error " << status << ": " << cstr << llendl;
-                                        worker->callbackHttpGet(NULL, -1, true);
-                                }
-                        }
-                        mFetcher->unlockQueue();
-                }
-        private:
-                LLTextureFetch* mFetcher;
-                LLUUID mID;
-        };
-#endif
        
+private:
        class CacheReadResponder : public LLTextureCache::ReadResponder
        {
        public:
@@ -179,20 +106,20 @@ private:
                LLUUID mID;
        };
        
-        class DecodeResponder : public LLResponder
+        class DecodeResponder : public LLImageDecodeThread::Responder
        {
        public:
                DecodeResponder(LLTextureFetch* fetcher, const LLUUID& id, LLTextureFetchWorker* worker)
                        : mFetcher(fetcher), mID(id), mWorker(worker)
                {
                }
-                virtual void completed(bool success)
+                virtual void completed(bool success, LLImageRaw* raw, LLImageRaw* aux)
                {
                        mFetcher->lockQueue();
                        LLTextureFetchWorker* worker = mFetcher->getWorker(mID);
                        if (worker)
                        {
-                                worker->callbackDecoded(success);
+                                worker->callbackDecoded(success, raw, aux);
                        }
                        mFetcher->unlockQueue();
                }
@@ -225,39 +152,47 @@ public:
        /*virtual*/ bool deleteOK(); // called from update() (WORK THREAD)
        ~LLTextureFetchWorker();
-        void relese() { --mActiveCount; }
+        void release() { --mActiveCount; }
+        void callbackHttpGet(const LLChannelDescriptors& channels,
+                                                 const LLIOPipe::buffer_ptr_t& buffer,
+                                                 bool last_block, bool success);
+        void callbackCacheRead(bool success, LLImageFormatted* image,
+                                                   S32 imagesize, BOOL islocal);
+        void callbackCacheWrite(bool success);
+        void callbackDecoded(bool success, LLImageRaw* raw, LLImageRaw* aux);
+        
+        void setGetStatus(U32 status, const std::string& reason)
+        {
+                mGetStatus = status;
+                mGetReason = reason;
+        }
 protected:
        LLTextureFetchWorker(LLTextureFetch* fetcher, const LLUUID& id, const LLHost& host,
                                                 F32 priority, S32 discard, S32 size);
+        LLTextureFetchWorker(LLTextureFetch* fetcher, const std::string& url, const LLUUID& id, const LLHost& host,
+                                                 F32 priority, S32 discard, S32 size);
 private:
        /*virtual*/ void startWork(S32 param); // called from addWork() (MAIN THREAD)
        /*virtual*/ void endWork(S32 param, bool aborted); // called from doWork() (MAIN THREAD)
-        virtual std::string getName() { return LLStringUtil::null; }
        void resetFormattedData();
        
        void setImagePriority(F32 priority);
        void setDesiredDiscard(S32 discard, S32 size);
        bool insertPacket(S32 index, U8* data, S32 size);
        void clearPackets();
+        void setupPacketData();
        U32 calcWorkPriority();
        void removeFromCache();
        bool processSimulatorPackets();
-        bool decodeImage();
        bool writeToCacheComplete();
        
-        void lockWorkData() { mWorkMutex.lock(); }
+        void lockWorkMutex() { mWorkMutex.lock(); }
-        void unlockWorkData() { mWorkMutex.unlock(); }
+        void unlockWorkMutex() { mWorkMutex.unlock(); }
-        void callbackURLReceived(const LLSD& data, bool success);
-        void callbackHttpGet(U8* data, S32 data_size, bool last_block);
-        void callbackCacheRead(bool success, LLImageFormatted* image,
-                                                   S32 imagesize, BOOL islocal);
-        void callbackCacheWrite(bool success);
-        void callbackDecoded(bool success);
-        
 private:
        enum e_state // mState
        {
@@ -268,8 +203,8 @@ private:
                CACHE_POST,
                LOAD_FROM_NETWORK,
                LOAD_FROM_SIMULATOR,
-                LOAD_FROM_HTTP_GET_URL,
+                SEND_HTTP_REQ,
-                LOAD_FROM_HTTP_GET_DATA,
+                WAIT_HTTP_REQ,
                DECODE_IMAGE,
                DECODE_IMAGE_UPDATE,
                WRITE_TO_CACHE,
@@ -280,19 +215,17 @@ private:
        {
                UNSENT = 0,
                QUEUED = 1,
-                SENT_SIM = 2,
+                SENT_SIM = 2
-                SENT_URL = 3,
-                SENT_HTTP = 4
        };
        static const char* sStateDescs[];
        e_state mState;
        LLTextureFetch* mFetcher;
-        LLImageWorker* mImageWorker;
        LLPointer<LLImageFormatted> mFormattedImage;
        LLPointer<LLImageRaw> mRawImage;
        LLPointer<LLImageRaw> mAuxImage;
        LLUUID mID;
        LLHost mHost;
+        std::string mUrl;
        U8 mType;
        F32 mImagePriority;
        U32 mWorkPriority;
@@ -314,15 +247,18 @@ private:
        S32 mCachedSize;
        BOOL mLoaded;
        e_request_state mSentRequest;
+        handle_t mDecodeHandle;
        BOOL mDecoded;
        BOOL mWritten;
        BOOL mNeedsAux;
        BOOL mHaveAllData;
        BOOL mInLocalCache;
+        S32 mHTTPFailCount;
        S32 mRetryAttempt;
-        std::string mURL;
        S32 mActiveCount;
+        U32 mGetStatus;
+        std::string mGetReason;
+        
        // Work Data
        LLMutex mWorkMutex;
        struct PacketData
@@ -340,25 +276,79 @@ private:
        U8 mImageCodec;
 };
-class LLTextureFetchLocalFileWorker : public LLTextureFetchWorker
+//////////////////////////////////////////////////////////////////////////////
-{
-friend class LLTextureFetch;
-protected:
-        LLTextureFetchLocalFileWorker(LLTextureFetch* fetcher, const std::string& filename, const LLUUID& id, const LLHost& host,
-                                                 F32 priority, S32 discard, S32 size)
-                :       LLTextureFetchWorker(fetcher, id, host, priority, discard, size),
-                        mFileName(filename)
-        {}
-private:
+class HTTPGetResponder : public LLCurl::Responder
-        /*virtual*/ std::string getName() { return mFileName; }
+{
+        LOG_CLASS(HTTPGetResponder);
+public:
+        HTTPGetResponder(LLTextureFetch* fetcher, const LLUUID& id, U64 startTime, S32 requestedSize, U32 offset)
+                : mFetcher(fetcher), mID(id), mStartTime(startTime), mRequestedSize(requestedSize), mOffset(offset)
+        {
+        }
+        ~HTTPGetResponder()
+        {
+        }
+        virtual void completedRaw(U32 status, const std::string& reason,
+                                                          const LLChannelDescriptors& channels,
+                                                          const LLIOPipe::buffer_ptr_t& buffer)
+        {
+                if ((gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog")) || (gSavedSettings.getBOOL("LogTextureDownloadsToSimulator")))
+                {
+                        mFetcher->mTextureInfo.setRequestStartTime(mID, mStartTime);
+                        U64 timeNow = LLTimer::getTotalTime();
+                        mFetcher->mTextureInfo.setRequestType(mID, LLTextureInfoDetails::REQUEST_TYPE_HTTP);
+                        mFetcher->mTextureInfo.setRequestSize(mID, mRequestedSize);
+                        mFetcher->mTextureInfo.setRequestOffset(mID, mOffset);
+                        mFetcher->mTextureInfo.setRequestCompleteTimeAndLog(mID, timeNow);
+                }
+                lldebugs << "HTTP COMPLETE: " << mID << llendl;
+                mFetcher->lockQueue();
+                LLTextureFetchWorker* worker = mFetcher->getWorker(mID);
+                if (worker)
+                {
+                        bool success = false;
+                        bool partial = false;
+                        if (200 <= status &&  status < 300)
+                        {
+                                success = true;
+                                if (HTTP_PARTIAL_CONTENT == status) // partial information (i.e. last block)
+                                {
+                                        partial = true;
+                                }
+                        }
+                        else
+                        {
+                                worker->setGetStatus(status, reason);
+//                              llwarns << status << ": " << reason << llendl;
+                        }
+                        if (!success)
+                        {
+                                worker->setGetStatus(status, reason);
+//                              llwarns << "CURL GET FAILED, status:" << status << " reason:" << reason << llendl;
+                        }
+                        mFetcher->removeFromHTTPQueue(mID);
+                        worker->callbackHttpGet(channels, buffer, partial, success);
+                }
+                else
+                {
+                        mFetcher->removeFromHTTPQueue(mID);
+                        llwarns << "Worker not found: " << mID << llendl;
+                }
+                mFetcher->unlockQueue();
+        }
+        
 private:
-        std::string mFileName;
+        LLTextureFetch* mFetcher;
+        LLUUID mID;
+        U64 mStartTime;
+        S32 mRequestedSize;
+        U32 mOffset;
 };
+//////////////////////////////////////////////////////////////////////////////
 //static
 const char* LLTextureFetchWorker::sStateDescs[] = {
@@ -368,8 +358,8 @@ const char* LLTextureFetchWorker::sStateDescs[] = {
        "CACHE_POST",
        "LOAD_FROM_NETWORK",
        "LOAD_FROM_SIMULATOR",
-        "LOAD_FROM_HTTP_URL",
+        "SEND_HTTP_REQ",
-        "LOAD_FROM_HTTP_DATA",
+        "WAIT_HTTP_REQ",
        "DECODE_IMAGE",
        "DECODE_IMAGE_UPDATE",
        "WRITE_TO_CACHE",
@@ -380,6 +370,7 @@ const char* LLTextureFetchWorker::sStateDescs[] = {
 // called from MAIN THREAD
 LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
+                                                                                   const std::string& url, // Optional URL
                                                                                   const LLUUID& id,    // Image UUID
                                                                                   const LLHost& host,  // Simulator host
                                                                                   F32 priority,                // Priority
@@ -388,9 +379,9 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
        : LLWorkerClass(fetcher, "TextureFetch"),
          mState(INIT),
          mFetcher(fetcher),
-          mImageWorker(NULL),
          mID(id),
          mHost(host),
+          mUrl(url),
          mImagePriority(priority),
          mWorkPriority(0),
          mRequestedPriority(0.f),
@@ -409,13 +400,16 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
          mCachedSize(0),
          mLoaded(FALSE),
          mSentRequest(UNSENT),
+          mDecodeHandle(0),
          mDecoded(FALSE),
          mWritten(FALSE),
          mNeedsAux(FALSE),
          mHaveAllData(FALSE),
          mInLocalCache(FALSE),
+          mHTTPFailCount(0),
          mRetryAttempt(0),
          mActiveCount(0),
+          mGetStatus(0),
          mWorkMutex(NULL),
          mFirstPacket(0),
          mLastPacket(-1),
@@ -425,12 +419,14 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
        calcWorkPriority();
        mType = host.isOk() ? LLImageBase::TYPE_AVATAR_BAKE : LLImageBase::TYPE_NORMAL;
 //      llinfos << "Create: " << mID << " mHost:" << host << " Discard=" << discard << llendl;
+        lockWorkMutex();
        if (!mFetcher->mDebugPause)
        {
                U32 work_priority = mWorkPriority | LLWorkerThread::PRIORITY_HIGH;
                addWork(0, work_priority );
        }
        setDesiredDiscard(discard, size);
+        unlockWorkMutex();
 }
 LLTextureFetchWorker::~LLTextureFetchWorker()
@@ -440,7 +436,7 @@ LLTextureFetchWorker::~LLTextureFetchWorker()
 //                      << " Requested=" << mRequestedDiscard
 //                      << " Desired=" << mDesiredDiscard << llendl;
        llassert_always(!haveWork());
-        lockWorkData();
+        lockWorkMutex();
        if (mCacheReadHandle != LLTextureCache::nullHandle())
        {
                mFetcher->mTextureCache->readComplete(mCacheReadHandle, true);
@@ -449,13 +445,9 @@ LLTextureFetchWorker::~LLTextureFetchWorker()
        {
                mFetcher->mTextureCache->writeComplete(mCacheWriteHandle, true);
        }
-        if (mImageWorker)
-        {
-                mImageWorker->scheduleDelete();
-        }
        mFormattedImage = NULL;
        clearPackets();
-        unlockWorkData();
+        unlockWorkMutex();
 }
 void LLTextureFetchWorker::clearPackets()
@@ -467,6 +459,38 @@ void LLTextureFetchWorker::clearPackets()
        mFirstPacket = 0;
 }
+void LLTextureFetchWorker::setupPacketData()
+{
+        S32 data_size = 0;
+        if (mFormattedImage.notNull())
+        {
+                data_size = mFormattedImage->getDataSize();
+        }
+        if (data_size > 0)
+        {
+                // Only used for simulator requests
+                mFirstPacket = (data_size - FIRST_PACKET_SIZE) / MAX_IMG_PACKET_SIZE + 1;
+                if (FIRST_PACKET_SIZE + (mFirstPacket-1) * MAX_IMG_PACKET_SIZE != data_size)
+                {
+                        llwarns << "Bad CACHED TEXTURE size: " << data_size << " removing." << llendl;
+                        removeFromCache();
+                        resetFormattedData();
+                        clearPackets();
+                }
+                else if (mFileSize > 0)
+                {
+                        mLastPacket = mFirstPacket-1;
+                        mTotalPackets = (mFileSize - FIRST_PACKET_SIZE + MAX_IMG_PACKET_SIZE-1) / MAX_IMG_PACKET_SIZE + 1;
+                }
+                else
+                {
+                        // This file was cached using HTTP so we have to refetch the first packet
+                        resetFormattedData();
+                        clearPackets();
+                }
+        }
+}
 U32 LLTextureFetchWorker::calcWorkPriority()
 {
 //      llassert_always(mImagePriority >= 0 && mImagePriority <= LLViewerImage::maxDecodePriority());
@@ -538,7 +562,6 @@ void LLTextureFetchWorker::resetFormattedData()
 // Called from MAIN thread
 void LLTextureFetchWorker::startWork(S32 param)
 {
-        llassert(mImageWorker == NULL);
        llassert(mFormattedImage.isNull());
 }
@@ -549,6 +572,14 @@ bool LLTextureFetchWorker::doWork(S32 param)
 {
        LLMutexLock lock(&mWorkMutex);
+        if ((mFetcher->isQuitting() || (mImagePriority <= 0.0f) || getFlags(LLWorkerClass::WCF_DELETE_REQUESTED)))
+        {
+                if (mState < WRITE_TO_CACHE)
+                {
+                        return true; // abort
+                }
+        }
+        
        if (mFetcher->mDebugPause)
        {
                return false; // debug: don't do any work
@@ -563,14 +594,6 @@ bool LLTextureFetchWorker::doWork(S32 param)
                mFetchTimer.reset();
        }
-        if (mImagePriority <= 0.0f)
-        {
-                if (mState < WRITE_TO_CACHE)
-                {
-                        return true; // cancel request
-                }
-        }
-        
        if (mState == INIT)
        {
                mRequestedDiscard = -1;
@@ -590,7 +613,6 @@ bool LLTextureFetchWorker::doWork(S32 param)
                clearPackets(); // TODO: Shouldn't be necessary
                mCacheReadHandle = LLTextureCache::nullHandle();
                mCacheWriteHandle = LLTextureCache::nullHandle();
-                mURL.clear();
                mState = LOAD_FROM_TEXTURE_CACHE;
                // fall through
        }
@@ -612,16 +634,27 @@ bool LLTextureFetchWorker::doWork(S32 param)
                        setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority); // Set priority first since Responder may change it
                        CacheReadResponder* responder = new CacheReadResponder(mFetcher, mID, mFormattedImage);
-                        if (getName().empty())
+                        if (mUrl.compare(0, 7, "file://") == 0)
+                        {
+                                // read file from local disk
+                                std::string filename = mUrl.substr(7, std::string::npos);
+                                mCacheReadHandle = mFetcher->mTextureCache->readFromCache(filename, mID, cache_priority,
+                                                                                                                                                  offset, size, responder);
+                        }
+                        else if (mUrl.empty())
                        {
                                mCacheReadHandle = mFetcher->mTextureCache->readFromCache(mID, cache_priority,
                                                                                                                                                  offset, size, responder);
                        }
                        else
                        {
-                                // read file from local disk
+                                if (!(mUrl.compare(0, 7, "http://") == 0))
-                                mCacheReadHandle = mFetcher->mTextureCache->readFromCache(getName(), mID, cache_priority,
+                                {
-                                                                                                                                                  offset, size, responder);
+                                        // *TODO:?remove this warning
+                                        llwarns << "Unknown URL Type: " << mUrl << llendl;
+                                }
+                                setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
+                                mState = SEND_HTTP_REQ;
                        }
                }
@@ -659,67 +692,92 @@ bool LLTextureFetchWorker::doWork(S32 param)
                }
                else
                {
-                        if (!getName().empty())
+                        if (mUrl.compare(0, 7, "file://") == 0)
                        {
                                // failed to load local file, we're done.
                                return true;
                        }
                        // need more data
-                        mState = LOAD_FROM_NETWORK;
+                        else
+                        {
+                                mState = LOAD_FROM_NETWORK;     // CACHE_POST --> LOAD_FROM_NETWORK, or SEND_HTTP_REQ see below.
+                                // This is true because mSentRequest is set to UNSENT in INIT and if we get here we went through
+                                // the states INIT --> LOAD_FROM_TEXTURE_CACHE --> CACHE_POST. Therefore either
+                                // mFetcher->addToNetworkQueue(this) is called below, or mState is set to SEND_HTTP_REQ.
+                                llassert(mSentRequest == UNSENT);
+                        }
                        // fall through
                }
        }
        if (mState == LOAD_FROM_NETWORK)
        {
-                if (mSentRequest == UNSENT)
+                bool get_url = gSavedSettings.getBOOL("ImagePipelineUseHTTP");
+                if (!mUrl.empty()) get_url = false;
+//              if (mHost != LLHost::invalid) get_url = false;
+                if ( get_url )
                {
-                        if (mFormattedImage.isNull())
+                        LLViewerRegion* region = NULL;
-                        {
+                        if (mHost == LLHost::invalid)
-                                mFormattedImage = new LLImageJ2C;
+                                region = gAgent.getRegion();
-                        }
+                        else
-                        // Add this to the network queue and sit here.
+                                region = LLWorld::getInstance()->getRegion(mHost);
-                        // LLTextureFetch::update() will send off a request which will change our state
-                        S32 data_size = mFormattedImage->getDataSize();
+                        if (region)
-                        if (data_size > 0)
                        {
-                                // Only used for simulator requests
+                                std::string http_url = region->getCapability("GetTexture");
-                                mFirstPacket = (data_size - FIRST_PACKET_SIZE) / MAX_IMG_PACKET_SIZE + 1;
+                                if (!http_url.empty())
-                                if (FIRST_PACKET_SIZE + (mFirstPacket-1) * MAX_IMG_PACKET_SIZE != data_size)
-                                {
-//                                      llwarns << "Bad CACHED TEXTURE size: " << data_size << " removing." << llendl;
-                                        removeFromCache();
-                                        resetFormattedData();
-                                        clearPackets();
-                                }
-                                else
                                {
-                                        mLastPacket = mFirstPacket-1;
+                                        mUrl = http_url + "/?texture_id=" + mID.asString().c_str();
-                                        mTotalPackets = (mFileSize - FIRST_PACKET_SIZE + MAX_IMG_PACKET_SIZE-1) / MAX_IMG_PACKET_SIZE + 1;
                                }
                        }
+                        else
+                        {
+                                llwarns << "Region not found for host: " << mHost << llendl;
+                        }
+                }
+                if (!mUrl.empty())
+                {
+                        mState = LLTextureFetchWorker::SEND_HTTP_REQ;
+                        setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
+                        // don't return, fall through to next state
+                }
+                else if (mSentRequest == UNSENT)
+                {
+                        // Add this to the network queue and sit here.
+                        // LLTextureFetch::update() will send off a request which will change our state
                        mRequestedSize = mDesiredSize;
                        mRequestedDiscard = mDesiredDiscard;
                        mSentRequest = QUEUED;
-                        mFetcher->lockQueue();
                        mFetcher->addToNetworkQueue(this);
-                        mFetcher->unlockQueue();
                        setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
+                        return false;
+                }
+                else
+                {
+                        // Shouldn't need to do anything here
+                        //llassert_always(mFetcher->mNetworkQueue.find(mID) != mFetcher->mNetworkQueue.end());
+                        // Make certain this is in the network queue
+                        //mFetcher->addToNetworkQueue(this);
+                        //setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
+                        return false;
                }
-                return false;
        }
        
        if (mState == LOAD_FROM_SIMULATOR)
        {
+                if (mFormattedImage.isNull())
+                {
+                        mFormattedImage = new LLImageJ2C;
+                }
                if (processSimulatorPackets())
                {
-                        mFetcher->lockQueue();
+                        mFetcher->removeFromNetworkQueue(this, false);
-                        mFetcher->removeFromNetworkQueue(this);
-                        mFetcher->unlockQueue();
                        if (mFormattedImage.isNull() || !mFormattedImage->getDataSize())
                        {
                                // processSimulatorPackets() failed
 //                              llwarns << "processSimulatorPackets() failed to load buffer" << llendl;
+                                // FIXME: Don't we need a mState change?
                                return true; // failed
                        }
                        setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
@@ -732,103 +790,91 @@ bool LLTextureFetchWorker::doWork(S32 param)
                return false;
        }
        
-#if 0
+        if (mState == SEND_HTTP_REQ)
-        if (mState == LOAD_FROM_HTTP_GET_URL)
+        {
-        {
+                {
-                if (!mSentRequest)
+                        const S32 HTTP_QUEUE_MAX_SIZE = 32;
-                {
+                        // *TODO: Integrate this with llviewerthrottle
-                        mSentRequest = TRUE;
+                        // Note: LLViewerThrottle uses dynamic throttling which makes sense for UDP,
-                        mLoaded = FALSE;
+                        // but probably not for Textures.
-                        std::string url;
+                        // Set the throttle to the entire bandwidth, assuming UDP packets will get priority
-                        LLViewerRegion* region = gAgent.getRegion();
+                        // when they are needed
-                        if (region)
+                        F32 max_bandwidth = mFetcher->mMaxBandwidth;
+                        if ((mFetcher->getHTTPQueueSize() >= HTTP_QUEUE_MAX_SIZE) ||
+                                (mFetcher->getTextureBandwidth() > max_bandwidth))
                        {
-                                url = region->getCapability("RequestTextureDownload");
+                                // Make normal priority and return (i.e. wait until there is room in the queue)
-                        }
+                                setPriority(LLWorkerThread::PRIORITY_NORMAL | mWorkPriority);
-                        if (!url.empty())
-                        {
-                                LLSD sd;
-                                sd = mID.asString();
-                                setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
-                                LLHTTPClient::post(url, sd, new URLResponder(mFetcher, mID));
                                return false;
                        }
-                        else
+                        
+                        S32 cur_size = 0;
+                        if (mFormattedImage.notNull())
                        {
-//                              llwarns << mID << ": HTTP get url failed, requesting from simulator" << llendl;
+                                cur_size = mFormattedImage->getDataSize(); // amount of data we already have
-                                mSentRequest = FALSE;
-                                mState = LOAD_FROM_SIMULATOR;
-                                return false;
                        }
-                }
-                else
-                {
-                        if (mLoaded)
-                        {
-                                if (!mURL.empty())
-                                {
-                                        mState = LOAD_FROM_HTTP_GET_DATA;
-                                        mSentRequest = FALSE; // reset
-                                        mLoaded = FALSE; // reset
-                                }
-                                else
-                                {
-//                                      llwarns << mID << ": HTTP get url is empty, requesting from simulator" << llendl;
-                                        mSentRequest = FALSE;
-                                        mState = LOAD_FROM_SIMULATOR;
-                                        return false;
-                                }
-                        }
-                }
-                // fall through
-        }
-        
-        if (mState == LOAD_FROM_HTTP_GET_DATA)
-        {
-                if (!mSentRequest)
-                {
-                        mSentRequest = TRUE;
-                        S32 cur_size = mFormattedImage->getDataSize(); // amount of data we already have
                        mRequestedSize = mDesiredSize;
                        mRequestedDiscard = mDesiredDiscard;
-#if 1 // *TODO: LLCurl::getByteRange is broken (ignores range)
-                        cur_size = 0;
-                        mFormattedImage->deleteData();
-#endif
                        mRequestedSize -= cur_size;
-                        //                        F32 priority = mImagePriority / (F32)LLViewerImage::maxDecodePriority(); // 0-1
+//                      F32 priority = mImagePriority / (F32)LLViewerImage::maxDecodePriority(); // 0-1
                        S32 offset = cur_size;
                        mBufferSize = cur_size; // This will get modified by callbackHttpGet()
-                        std::string url;
+                        
-                        if (mURL.empty())
+                        bool res = false;
+                        if (!mUrl.empty())
                        {
-                                //url = "http://asset.agni/0000002f-38ae-0e17-8e72-712e58964e9c.texture";
+                                mLoaded = FALSE;
-                                std::stringstream urlstr;
+                                mGetStatus = 0;
-                                urlstr << "http://asset.agni/" << mID.asString() << ".texture";
+                                mGetReason.clear();
-                                url = urlstr.str();
+                                lldebugs << "HTTP GET: " << mID << " Offset: " << offset
+                                                << " Bytes: " << mRequestedSize
+                                                << " Bandwidth(kbps): " << mFetcher->getTextureBandwidth() << "/" << max_bandwidth
+                                                << llendl;
+                                setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
+                                mState = WAIT_HTTP_REQ; 
+                                mFetcher->addToHTTPQueue(mID);
+                                // Will call callbackHttpGet when curl request completes
+                                std::vector<std::string> headers;
+                                headers.push_back("Accept: image/x-j2c");
+                                res = mFetcher->mCurlGetRequest->getByteRange(mUrl, headers, offset, mRequestedSize,
+                                                                                                                          new HTTPGetResponder(mFetcher, mID, LLTimer::getTotalTime(), mRequestedSize, offset));
                        }
-                        else
+                        if (!res)
                        {
-                                url = mURL;
+                                llwarns << "HTTP GET request failed for " << mID << llendl;
+                                resetFormattedData();
+                                ++mHTTPFailCount;
+                                return true; // failed
                        }
-                        mLoaded = FALSE;
+                        // fall through
-//                      llinfos << "HTTP GET: " << mID << " Offset: " << offset << " Bytes: " << mRequestedSize << llendl;
-                        setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
-                        LLCurl::getByteRange(url, offset, mRequestedSize,
-                                                                 new HTTPGetResponder(mFetcher, mID)); // *TODO: use mWorkPriority
-                        return false; // not done
                }
+        }
+        
+        if (mState == WAIT_HTTP_REQ)
+        {
                if (mLoaded)
                {
-                        S32 cur_size = mFormattedImage->getDataSize();
+                        S32 cur_size = mFormattedImage.notNull() ? mFormattedImage->getDataSize() : 0;
                        if (mRequestedSize < 0)
                        {
-//                              llwarns << "http get failed for: " << mID << llendl;
+                                const S32 HTTP_MAX_RETRY_COUNT = 4;
+                                llinfos << "HTTP GET failed for: " << mUrl
+                                                << " Status: " << mGetStatus << " Reason: " << mGetReason
+                                                << " Try:" << mHTTPFailCount+1 << "/" << HTTP_MAX_RETRY_COUNT << llendl;
                                if (cur_size == 0)
                                {
-                                        resetFormattedData();
+                                        ++mHTTPFailCount;
-                                        return true; // failed
+                                        if (mGetStatus == HTTP_NOT_FOUND || mHTTPFailCount >= HTTP_MAX_RETRY_COUNT)
+                                        {
+                                                resetFormattedData();
+                                                return true; // failed
+                                        }
+                                        else
+                                        {
+                                                mState = SEND_HTTP_REQ;
+                                                return false; // retry
+                                        }
                                }
                                else
                                {
@@ -836,6 +882,18 @@ bool LLTextureFetchWorker::doWork(S32 param)
                                        return false; // use what we have
                                }
                        }
+                        
+                        if (mFormattedImage.isNull())
+                        {
+                                // For now, create formatted image based on extension
+                                std::string extension = gDirUtilp->getExtension(mUrl);
+                                mFormattedImage = LLImageFormatted::createFromType(LLImageBase::getCodecFromExtension(extension));
+                                if (mFormattedImage.isNull())
+                                {
+                                        mFormattedImage = new LLImageJ2C; // default
+                                }
+                        }
+                        
                        llassert_always(mBufferSize == cur_size + mRequestedSize);
                        if (mHaveAllData)
                        {
@@ -854,16 +912,16 @@ bool LLTextureFetchWorker::doWork(S32 param)
                        mBuffer = NULL;
                        mBufferSize = 0;
                        mLoadedDiscard = mRequestedDiscard;
-                        setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
                        mState = DECODE_IMAGE;
+                        setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
+                        return false;
+                }
+                else
+                {
+                        setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
                        return false;
                }
-                // NOTE: Priority gets updated when the http get completes (in callbackHTTPGet())
-                setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
-                return false;
        }
-#endif
        
        if (mState == DECODE_IMAGE)
        {
@@ -871,19 +929,19 @@ bool LLTextureFetchWorker::doWork(S32 param)
                setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority); // Set priority first since Responder may change it
                mRawImage = NULL;
                mAuxImage = NULL;
-                llassert_always(mImageWorker == NULL);
                llassert_always(mFormattedImage.notNull());
                S32 discard = mHaveAllData ? 0 : mLoadedDiscard;
                U32 image_priority = LLWorkerThread::PRIORITY_NORMAL | mWorkPriority;
                mDecoded  = FALSE;
                mState = DECODE_IMAGE_UPDATE;
-                mImageWorker = new LLImageWorker(mFormattedImage, image_priority, discard, new DecodeResponder(mFetcher, mID, this));
+                mDecodeHandle = mFetcher->mImageDecodeThread->decodeImage(mFormattedImage, image_priority, discard, mNeedsAux,
-                // fall though (need to call requestDecodedData() to start work)
+                                                                                                                                  new DecodeResponder(mFetcher, mID, this));
+                // fall though
        }
        
        if (mState == DECODE_IMAGE_UPDATE)
        {
-                if (decodeImage())
+                if (mDecoded)
                {
                        if (mDecodedDiscard < 0)
                        {
@@ -891,6 +949,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
                                {
                                        // Cache file should be deleted, try again
 //                                      llwarns << mID << ": Decode of cached file failed (removed), retrying" << llendl;
+                                        llassert_always(mDecodeHandle == 0);
                                        mFormattedImage = NULL;
                                        ++mRetryAttempt;
                                        setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
@@ -918,9 +977,10 @@ bool LLTextureFetchWorker::doWork(S32 param)
        if (mState == WRITE_TO_CACHE)
        {
-                if (mInLocalCache || !mFileSize || mSentRequest == UNSENT)
+                if (mInLocalCache || mSentRequest == UNSENT || mFormattedImage.isNull())
                {
-                        // If we're in a local cache or we didn't actually receive any new data, skip
+                        // If we're in a local cache or we didn't actually receive any new data,
+                        // or we failed to load anything, skip
                        mState = DONE;
                        return false;
                }
@@ -979,10 +1039,10 @@ bool LLTextureFetchWorker::doWork(S32 param)
 // Called from MAIN thread
 void LLTextureFetchWorker::endWork(S32 param, bool aborted)
 {
-        if (mImageWorker)
+        if (mDecodeHandle != 0)
        {
-                mImageWorker->scheduleDelete();
+                mFetcher->mImageDecodeThread->abortRequest(mDecodeHandle, false);
-                mImageWorker = NULL;
+                mDecodeHandle = 0;
        }
        mFormattedImage = NULL;
 }
@@ -1035,7 +1095,7 @@ bool LLTextureFetchWorker::deleteOK()
        if ((haveWork() &&
                 // not ok to delete from these states
-                 ((mState >= LOAD_FROM_HTTP_GET_URL && mState <= LOAD_FROM_HTTP_GET_DATA) ||
+                 ((mState >= SEND_HTTP_REQ && mState <= WAIT_HTTP_REQ) ||
                  (mState >= WRITE_TO_CACHE && mState <= WAIT_ON_WRITE))))
        {
                delete_ok = false;
@@ -1044,7 +1104,6 @@ bool LLTextureFetchWorker::deleteOK()
        return delete_ok;
 }
 void LLTextureFetchWorker::removeFromCache()
 {
        if (!mInLocalCache)
@@ -1061,6 +1120,7 @@ bool LLTextureFetchWorker::processSimulatorPackets()
        if (mFormattedImage.isNull() || mRequestedSize < 0)
        {
                // not sure how we got here, but not a valid state, abort!
+                llassert_always(mDecodeHandle == 0);
                mFormattedImage = NULL;
                return true;
        }
@@ -1074,6 +1134,12 @@ bool LLTextureFetchWorker::processSimulatorPackets()
                        buffer_size += mPackets[i]->mSize;
                }
                bool have_all_data = mLastPacket >= mTotalPackets-1;
+                if (mRequestedSize <= 0)
+                {
+                        // We received a packed but haven't requested anything yet (edge case)
+                        // Return true (we're "done") since we didn't request anything
+                        return true;
+                }
                if (buffer_size >= mRequestedSize || have_all_data)
                {
                        /// We have enough (or all) data
@@ -1109,50 +1175,36 @@ bool LLTextureFetchWorker::processSimulatorPackets()
 //////////////////////////////////////////////////////////////////////////////
-void LLTextureFetchWorker::callbackURLReceived(const LLSD& data, bool success)
+void LLTextureFetchWorker::callbackHttpGet(const LLChannelDescriptors& channels,
+                                                                                   const LLIOPipe::buffer_ptr_t& buffer,
+                                                                                   bool last_block, bool success)
 {
-#if 0
        LLMutexLock lock(&mWorkMutex);
-        if (!mSentRequest || mState != LOAD_FROM_HTTP_GET_URL)
-        {
-                llwarns << "callbackURLReceived for unrequested fetch worker, req="
-                                << mSentRequest << " state= " << mState << llendl;
-                return;
-        }
-        if (success)
-        {
-                mURL = data.asString();
-        }
-        mLoaded = TRUE;
-        setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
-#endif
-}
-//////////////////////////////////////////////////////////////////////////////
+        if (mState != WAIT_HTTP_REQ)
-void LLTextureFetchWorker::callbackHttpGet(U8* data, S32 data_size, bool last_block)
-{
-#if 0
-        LLMutexLock lock(&mWorkMutex);
-        if (!mSentRequest || mState != LOAD_FROM_HTTP_GET_DATA)
        {
-                llwarns << "callbackHttpGet for unrequested fetch worker, req="
+                llwarns << "callbackHttpGet for unrequested fetch worker: " << mID
-                                << mSentRequest << " state= " << mState << llendl;
+                                << " req=" << mSentRequest << " state= " << mState << llendl;
                return;
        }
-//      llinfos << "HTTP RECEIVED: " << mID.asString() << " Bytes: " << data_size << llendl;
        if (mLoaded)
        {
                llwarns << "Duplicate callback for " << mID.asString() << llendl;
                return; // ignore duplicate callback
        }
-        if (data_size >= 0)
+        if (success)
        {
+                // get length of stream:
+                S32 data_size = buffer->countAfter(channels.in(), NULL);
+                gImageList.sTextureBits += data_size * 8; // Approximate - does not include header bits
+        
+                //llinfos << "HTTP RECEIVED: " << mID.asString() << " Bytes: " << data_size << llendl;
                if (data_size > 0)
                {
+                        // *TODO: set the formatted image data here directly to avoid the copy
                        mBuffer = new U8[data_size];
-                        // *TODO: set the formatted image data here
+                        buffer->readAfter(channels.in(), NULL, mBuffer, data_size);
-                        memcpy(mBuffer, data, data_size);
                        mBufferSize += data_size;
                        if (data_size < mRequestedSize || last_block == true)
                        {
@@ -1160,10 +1212,11 @@ void LLTextureFetchWorker::callbackHttpGet(U8* data, S32 data_size, bool last_bl
                        }
                        else if (data_size > mRequestedSize)
                        {
-                                // *TODO: This will happen until we fix LLCurl::getByteRange()
+                                // *TODO: This shouldn't be happening any more
-//                              llinfos << "HUH?" << llendl;
+                                llwarns << "data_size = " << data_size << " > requested: " << mRequestedSize << llendl;
                                mHaveAllData = TRUE;
-                                mFormattedImage->deleteData();
+                                llassert_always(mDecodeHandle == 0);
+                                mFormattedImage = NULL; // discard any previous data we had
                                mBufferSize = data_size;
                        }
                }
@@ -1181,7 +1234,6 @@ void LLTextureFetchWorker::callbackHttpGet(U8* data, S32 data_size, bool last_bl
        }
        mLoaded = TRUE;
        setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
-#endif
 }
 //////////////////////////////////////////////////////////////////////////////
@@ -1197,7 +1249,7 @@ void LLTextureFetchWorker::callbackCacheRead(bool success, LLImageFormatted* ima
        }
        if (success)
        {
-                llassert_always(imagesize > 0);
+                llassert_always(imagesize >= 0);
                mFileSize = imagesize;
                mFormattedImage = image;
                mImageCodec = image->getCodec();
@@ -1225,65 +1277,49 @@ void LLTextureFetchWorker::callbackCacheWrite(bool success)
 //////////////////////////////////////////////////////////////////////////////
-void LLTextureFetchWorker::callbackDecoded(bool success)
+void LLTextureFetchWorker::callbackDecoded(bool success, LLImageRaw* raw, LLImageRaw* aux)
 {
+        LLMutexLock lock(&mWorkMutex);
+        if (mDecodeHandle == 0)
+        {
+                return; // aborted, ignore
+        }
        if (mState != DECODE_IMAGE_UPDATE)
        {
 //              llwarns << "Decode callback for " << mID << " with state = " << mState << llendl;
+                mDecodeHandle = 0;
                return;
        }
-//      llinfos << mID << " : DECODE COMPLETE " << llendl;
+        llassert_always(mFormattedImage.notNull());
-        setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
+        
-}
+        mDecodeHandle = 0;
+        if (success)
-//////////////////////////////////////////////////////////////////////////////
-bool LLTextureFetchWorker::decodeImage()
-{
-        if(!mImageWorker)
-        {
-                //LLTextureFetchWorker is aborted, skip image decoding.
-                return true ;
-        }
-        bool res = true;
-        if (mRawImage.isNull())
-        {
-                res = false;
-                if (mImageWorker->requestDecodedData(mRawImage, -1))
-                {
-                        res = true;
-//                      llinfos << mID << " : BASE DECODE FINISHED" << llendl;
-                }
-        }
-        if (res &&
-                (mRawImage.notNull() && mRawImage->getDataSize() > 0) &&
-                (mNeedsAux && mAuxImage.isNull()))
        {
-                res = false;
+                mRawImage = raw;
-                if (mImageWorker->requestDecodedAuxData(mAuxImage, 4, -1))
+                mAuxImage = aux;
-                {
+                mDecodedDiscard = mFormattedImage->getDiscardLevel();
-                        res = true;
+//              llinfos << mID << " : DECODE FINISHED. DISCARD: " << mDecodedDiscard << llendl;
-//                      llinfos << mID << " : AUX DECODE FINISHED" << llendl;
-                }
        }
-        if (res)
+        else
        {
-                if ((mRawImage.notNull() && mRawImage->getDataSize() > 0) &&
+                if (mFormattedImage.notNull())
-                        (!mNeedsAux || (mAuxImage.notNull() && mAuxImage->getDataSize() > 0)))
                {
-                        mDecodedDiscard = mFormattedImage->getDiscardLevel();
+                        LL_WARNS("http-texture") << "DECODE FAILED: id = " << mID << ", Discard = " << (S32)mFormattedImage->getDiscardLevel() << LL_ENDL;
-//                      llinfos << mID << " : DECODE FINISHED. DISCARD: " << mDecodedDiscard << llendl;
                }
                else
                {
-//                      llwarns << "DECODE FAILED: " << mID << " Discard: " << (S32)mFormattedImage->getDiscardLevel() << llendl;
+                        LL_WARNS("http-texture") << "DECODE FAILED: id = " << mID << ", mFormattedImage is Null!" << LL_ENDL;
-                        removeFromCache();
                }
-                mImageWorker->scheduleDelete();
+                removeFromCache();
-                mImageWorker = NULL;
+                mDecodedDiscard = -1; // Redundant, here for clarity and paranoia
        }
-        return res;
+        mDecoded = TRUE;
+//      llinfos << mID << " : DECODE COMPLETE " << llendl;
+        setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
+        // Set the decode flag at the end of the callback or we trigger race conditions between the fetch thread and the 
+        // decode threads that's calling this callback. The fetch thread might set mFormattedImage to NULL before we
+        // have time here to call getDiscardLevel() which causes crashes
+        mDecoded = TRUE;
 }
 //////////////////////////////////////////////////////////////////////////////
@@ -1314,15 +1350,21 @@ bool LLTextureFetchWorker::writeToCacheComplete()
 //////////////////////////////////////////////////////////////////////////////
 // public
-LLTextureFetch::LLTextureFetch(LLTextureCache* cache, bool threaded)
+LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* imagedecodethread, bool threaded)
        : LLWorkerThread("TextureFetch", threaded),
          mDebugCount(0),
          mDebugPause(FALSE),
          mPacketCount(0),
          mBadPacketCount(0),
          mQueueMutex(getAPRPool()),
-          mTextureCache(cache)
+          mNetworkQueueMutex(getAPRPool()),
+          mTextureCache(cache),
+          mImageDecodeThread(imagedecodethread),
+          mTextureBandwidth(0),
+          mCurlGetRequest(NULL)
 {
+        mMaxBandwidth = gSavedSettings.getF32("ThrottleBandwidthKBPS");
+        mTextureInfo.setUpLogging(gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog"), gSavedSettings.getBOOL("LogTextureDownloadsToSimulator"), gSavedSettings.getU32("TextureLoggingThreshold"));
 }
 LLTextureFetch::~LLTextureFetch()
@@ -1330,13 +1372,7 @@ LLTextureFetch::~LLTextureFetch()
        // ~LLQueuedThread() called here
 }
-bool LLTextureFetch::createRequest(const LLUUID& id, const LLHost& host, F32 priority,
+bool LLTextureFetch::createRequest(const std::string& url, const LLUUID& id, const LLHost& host, F32 priority,
-                                                                        S32 w, S32 h, S32 c, S32 desired_discard, bool needs_aux)
-{
-        return createRequest(LLStringUtil::null, id, host, priority, w, h, c, desired_discard, needs_aux);
-}
-bool LLTextureFetch::createRequest(const std::string& filename, const LLUUID& id, const LLHost& host, F32 priority,
                                                                   S32 w, S32 h, S32 c, S32 desired_discard, bool needs_aux)
 {
        if (mDebugPause)
@@ -1361,7 +1397,14 @@ bool LLTextureFetch::createRequest(const std::string& filename, const LLUUID& id
        }
        S32 desired_size;
-        if (desired_discard == 0)
+        std::string exten = gDirUtilp->getExtension(url);
+        if (!url.empty() && (!exten.empty() && LLImageBase::getCodecFromExtension(exten) != IMG_CODEC_J2C))
+        {
+                // Only do partial requests for J2C at the moment
+                //llinfos << "Merov : LLTextureFetch::createRequest(), blocking fetch on " << url << llendl; 
+                desired_size = MAX_IMAGE_DATA_SIZE;
+        }
+        else if (desired_discard == 0)
        {
                // if we want the entire image, and we know its size, then get it all
                // (calcDataSizeJ2C() below makes assumptions about how the image
@@ -1389,28 +1432,25 @@ bool LLTextureFetch::createRequest(const std::string& filename, const LLUUID& id
                {
                        return false; // need to wait for previous aborted request to complete
                }
-                worker->lockWorkData();
+                worker->lockWorkMutex();
                worker->setImagePriority(priority);
                worker->setDesiredDiscard(desired_discard, desired_size);
-                worker->unlockWorkData();
+                worker->unlockWorkMutex();
                if (!worker->haveWork())
                {
+                        worker->lockWorkMutex();
+                        if (worker->mState == LLTextureFetchWorker::LOAD_FROM_NETWORK || worker->mState == LLTextureFetchWorker::LOAD_FROM_SIMULATOR)
+                        {
+                                removeFromNetworkQueue(worker, true);
+                        }
                        worker->mState = LLTextureFetchWorker::INIT;
+                        worker->unlockWorkMutex();
                        worker->addWork(0, LLWorkerThread::PRIORITY_HIGH | worker->mWorkPriority);
                }
        }
        else
        {
-                if (filename.empty())
+                worker = new LLTextureFetchWorker(this, url, id, host, priority, desired_discard, desired_size);
-                {
-                        // do remote fetch
-                        worker = new LLTextureFetchWorker(this, id, host, priority, desired_discard, desired_size);
-                }
-                else
-                {
-                        // do local file fetch
-                        worker = new LLTextureFetchLocalFileWorker(this, filename, id, host, priority, desired_discard, desired_size);
-                }
                mRequestMap[id] = worker;
        }
        worker->mActiveCount++;
@@ -1430,10 +1470,9 @@ void LLTextureFetch::deleteRequest(const LLUUID& id, bool cancel)
 }
 // protected
-// call lockQueue() first!
 void LLTextureFetch::addToNetworkQueue(LLTextureFetchWorker* worker)
 {
+        LLMutexLock lock(&mNetworkQueueMutex);
        if (mRequestMap.find(worker->mID) != mRequestMap.end())
        {
                // only add to the queue if in the request map
@@ -1447,10 +1486,27 @@ void LLTextureFetch::addToNetworkQueue(LLTextureFetchWorker* worker)
        }
 }
-// call lockQueue() first!
+void LLTextureFetch::removeFromNetworkQueue(LLTextureFetchWorker* worker, bool cancel)
-void LLTextureFetch::removeFromNetworkQueue(LLTextureFetchWorker* worker)
+{
+        LLMutexLock lock(&mNetworkQueueMutex);
+        size_t erased = mNetworkQueue.erase(worker->mID);
+        if (cancel && erased > 0)
+        {
+                mCancelQueue[worker->mHost].insert(worker->mID);
+        }
+}
+// protected
+void LLTextureFetch::addToHTTPQueue(const LLUUID& id)
+{
+        LLMutexLock lock(&mNetworkQueueMutex);
+        mHTTPTextureQueue.insert(id);
+}
+void LLTextureFetch::removeFromHTTPQueue(const LLUUID& id)
 {
-        mNetworkQueue.erase(worker->mID);
+        LLMutexLock lock(&mNetworkQueueMutex);
+        mHTTPTextureQueue.erase(id);
 }
 // call lockQueue() first!
@@ -1458,11 +1514,7 @@ void LLTextureFetch::removeRequest(LLTextureFetchWorker* worker, bool cancel)
 {
        size_t erased_1 = mRequestMap.erase(worker->mID);
        llassert_always(erased_1 > 0) ;
-        size_t erased = mNetworkQueue.erase(worker->mID);
+        removeFromNetworkQueue(worker, cancel);
-        if (cancel && erased > 0)
-        {
-                mCancelQueue[worker->mHost].insert(worker->mID);
-        }
        llassert_always(!(worker->getFlags(LLWorkerClass::WCF_DELETE_REQUESTED))) ;
        worker->scheduleDelete();       
@@ -1511,7 +1563,7 @@ bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level,
                }
                else
                {
-                        worker->lockWorkData();
+                        worker->lockWorkMutex();
                        if ((worker->mDecodedDiscard >= 0) &&
                                (worker->mDecodedDiscard < discard_level || discard_level < 0) &&
                                (worker->mState >= LLTextureFetchWorker::WAIT_ON_WRITE))
@@ -1521,7 +1573,7 @@ bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level,
                                if (worker->mRawImage) raw = worker->mRawImage;
                                if (worker->mAuxImage) aux = worker->mAuxImage;
                        }
-                        worker->unlockWorkData();
+                        worker->unlockWorkMutex();
                }
        }
        else
@@ -1538,9 +1590,9 @@ bool LLTextureFetch::updateRequestPriority(const LLUUID& id, F32 priority)
        LLTextureFetchWorker* worker = getWorker(id);
        if (worker)
        {
-                worker->lockWorkData();
+                worker->lockWorkMutex();
                worker->setImagePriority(priority);
-                worker->unlockWorkData();
+                worker->unlockWorkMutex();
                res = true;
        }
        return res;
@@ -1548,40 +1600,106 @@ bool LLTextureFetch::updateRequestPriority(const LLUUID& id, F32 priority)
 //////////////////////////////////////////////////////////////////////////////
+// MAIN THREAD
 //virtual
 S32 LLTextureFetch::update(U32 max_time_ms)
 {
        S32 res;
+        
+        mMaxBandwidth = gSavedSettings.getF32("ThrottleBandwidthKBPS");
+        
        res = LLWorkerThread::update(max_time_ms);
        
-        const F32 REQUEST_TIME = 1.f;
+        if (!mDebugPause)
-        // Periodically, gather the list of textures that need data from the network
-        // And send the requests out to the simulators
-        if (mNetworkTimer.getElapsedTimeF32() >= REQUEST_TIME)
        {
-                mNetworkTimer.reset();
                sendRequestListToSimulators();
        }
        
        return res;
 }
+// WORKER THREAD
+void LLTextureFetch::startThread()
+{
+        // Construct mCurlGetRequest from Worker Thread
+        mCurlGetRequest = new LLCurlRequest();
+}
+// WORKER THREAD
+void LLTextureFetch::endThread()
+{
+        // Destroy mCurlGetRequest from Worker Thread
+        delete mCurlGetRequest;
+        mCurlGetRequest = NULL;
+}
+// WORKER THREAD
+void LLTextureFetch::threadedUpdate()
+{
+        llassert_always(mCurlGetRequest);
+        
+        // Limit update frequency
+        const F32 PROCESS_TIME = 0.05f; 
+        static LLFrameTimer process_timer;
+        if (process_timer.getElapsedTimeF32() < PROCESS_TIME)
+        {
+                return;
+        }
+        process_timer.reset();
+        
+        // Update Curl on same thread as mCurlGetRequest was constructed
+        S32 processed = mCurlGetRequest->process();
+        if (processed > 0)
+        {
+                lldebugs << "processed: " << processed << " messages." << llendl;
+        }
+#if 0
+        const F32 INFO_TIME = 1.0f; 
+        static LLFrameTimer info_timer;
+        if (info_timer.getElapsedTimeF32() >= INFO_TIME)
+        {
+                S32 q = mCurlGetRequest->getQueued();
+                if (q > 0)
+                {
+                        llinfos << "Queued gets: " << q << llendl;
+                        info_timer.reset();
+                }
+        }
+#endif
+        
+}
 //////////////////////////////////////////////////////////////////////////////
 void LLTextureFetch::sendRequestListToSimulators()
 {
+        // All requests
+        const F32 REQUEST_DELTA_TIME = 0.10f; // 10 fps
+        
+        // Sim requests
        const S32 IMAGES_PER_REQUEST = 50;
-        const F32 LAZY_FLUSH_TIMEOUT = 15.f; // 10.0f // temp
+        const F32 SIM_LAZY_FLUSH_TIMEOUT = 10.0f; // temp
        const F32 MIN_REQUEST_TIME = 1.0f;
        const F32 MIN_DELTA_PRIORITY = 1000.f;
-        LLMutexLock lock(&mQueueMutex);
+        // Periodically, gather the list of textures that need data from the network
+        // And send the requests out to the simulators
+        static LLFrameTimer timer;
+        if (timer.getElapsedTimeF32() < REQUEST_DELTA_TIME)
+        {
+                return;
+        }
+        timer.reset();
        
+        LLMutexLock lock(&mQueueMutex);
        // Send requests
        typedef std::set<LLTextureFetchWorker*,LLTextureFetchWorker::Compare> request_list_t;
        typedef std::map< LLHost, request_list_t > work_request_map_t;
        work_request_map_t requests;
+        {
+        LLMutexLock lock2(&mNetworkQueueMutex);
        for (queue_t::iterator iter = mNetworkQueue.begin(); iter != mNetworkQueue.end(); )
        {
                queue_t::iterator curiter = iter++;
@@ -1591,65 +1709,66 @@ void LLTextureFetch::sendRequestListToSimulators()
                        mNetworkQueue.erase(curiter);
                        continue; // paranoia
                }
+                llassert(req->mState == LLTextureFetchWorker::LOAD_FROM_NETWORK || LLTextureFetchWorker::LOAD_FROM_SIMULATOR);
+                if ((req->mState != LLTextureFetchWorker::LOAD_FROM_NETWORK) &&
+                        (req->mState != LLTextureFetchWorker::LOAD_FROM_SIMULATOR))
+                {
+                        // We really should never ever get here anymore.
+                        llwarns << "SNOW-119 failure: Worker: " << req->mID << " in mNetworkQueue but in wrong state: " << req->mState << llendl;
+                        mNetworkQueue.erase(curiter);
+                        continue;
+                }
                if (req->mID == mDebugID)
                {
                        mDebugCount++; // for setting breakpoints
                }
-                if (req->mTotalPackets > 0 && req->mLastPacket >= req->mTotalPackets-1)
+                if (req->mSentRequest == LLTextureFetchWorker::SENT_SIM &&
+                        req->mTotalPackets > 0 &&
+                        req->mLastPacket >= req->mTotalPackets-1)
                {
                        // We have all the packets... make sure this is high priority
 //                      req->setPriority(LLWorkerThread::PRIORITY_HIGH | req->mWorkPriority);
                        continue;
                }
                F32 elapsed = req->mRequestedTimer.getElapsedTimeF32();
-                F32 delta_priority = llabs(req->mRequestedPriority - req->mImagePriority);
-                if ((req->mSimRequestedDiscard != req->mDesiredDiscard) ||
-                        (delta_priority > MIN_DELTA_PRIORITY && elapsed >= MIN_REQUEST_TIME) ||
-                        (elapsed >= LAZY_FLUSH_TIMEOUT))
                {
-                        requests[req->mHost].insert(req);
+                        F32 delta_priority = llabs(req->mRequestedPriority - req->mImagePriority);
+                        if ((req->mSimRequestedDiscard != req->mDesiredDiscard) ||
+                                (delta_priority > MIN_DELTA_PRIORITY && elapsed >= MIN_REQUEST_TIME) ||
+                                (elapsed >= SIM_LAZY_FLUSH_TIMEOUT))
+                        {
+                                requests[req->mHost].insert(req);
+                        }
                }
        }
-        std::string http_url;
-#if 0
-        if (gSavedSettings.getBOOL("ImagePipelineUseHTTP"))
-        {
-                LLViewerRegion* region = gAgent.getRegion();
-                if (region)
-                {
-                        http_url = region->getCapability("RequestTextureDownload");
-                }
        }
-#endif
-        
        for (work_request_map_t::iterator iter1 = requests.begin();
                 iter1 != requests.end(); ++iter1)
        {
-                bool use_http = http_url.empty() ? false : true;
                LLHost host = iter1->first;
                // invalid host = use agent host
                if (host == LLHost::invalid)
                {
                        host = gAgent.getRegionHost();
                }
-                else
-                {
-                        use_http = false;
-                }
-                if (use_http)
+                S32 sim_request_count = 0;
-                {
+                
-                }
+                for (request_list_t::iterator iter2 = iter1->second.begin();
-                else
+                         iter2 != iter1->second.end(); ++iter2)
                {
-                        S32 request_count = 0;
+                        LLTextureFetchWorker* req = *iter2;
-                        for (request_list_t::iterator iter2 = iter1->second.begin();
+                        if (gMessageSystem)
-                                 iter2 != iter1->second.end(); ++iter2)
                        {
-                                LLTextureFetchWorker* req = *iter2;
+                                if (req->mSentRequest != LLTextureFetchWorker::SENT_SIM)
-                                req->mSentRequest = LLTextureFetchWorker::SENT_SIM;
+                                {
-                                if (0 == request_count)
+                                        // Initialize packet data based on data read from cache
+                                        req->lockWorkMutex();
+                                        req->setupPacketData();
+                                        req->unlockWorkMutex();
+                                }
+                                if (0 == sim_request_count)
                                {
                                        gMessageSystem->newMessageFast(_PREHASH_RequestImage);
                                        gMessageSystem->nextBlockFast(_PREHASH_AgentData);
@@ -1666,30 +1785,42 @@ void LLTextureFetch::sendRequestListToSimulators()
 //                              llinfos << "IMAGE REQUEST: " << req->mID << " Discard: " << req->mDesiredDiscard
 //                                              << " Packet: " << packet << " Priority: " << req->mImagePriority << llendl;
-                                req->lockWorkData();
+                                if ((gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog")) || (gSavedSettings.getBOOL("LogTextureDownloadsToSimulator")))
+                                {
+                                        mTextureInfo.setRequestStartTime(req->mID, LLTimer::getTotalTime());
+                                        mTextureInfo.setRequestOffset(req->mID, 0);
+                                        mTextureInfo.setRequestSize(req->mID, 0);
+                                        mTextureInfo.setRequestType(req->mID, LLTextureInfoDetails::REQUEST_TYPE_UDP);
+                                }
+                                req->lockWorkMutex();
+                                req->mSentRequest = LLTextureFetchWorker::SENT_SIM;
                                req->mSimRequestedDiscard = req->mDesiredDiscard;
                                req->mRequestedPriority = req->mImagePriority;
                                req->mRequestedTimer.reset();
-                                req->unlockWorkData();
+                                req->unlockWorkMutex();
-                                request_count++;
+                                sim_request_count++;
-                                if (request_count >= IMAGES_PER_REQUEST)
+                                if (sim_request_count >= IMAGES_PER_REQUEST)
                                {
-//                                      llinfos << "REQUESTING " << request_count << " IMAGES FROM HOST: " << host.getIPString() << llendl;
+//                                      llinfos << "REQUESTING " << sim_request_count << " IMAGES FROM HOST: " << host.getIPString() << llendl;
                                        gMessageSystem->sendSemiReliable(host, NULL, NULL);
-                                        request_count = 0;
+                                        sim_request_count = 0;
                                }
                        }
-                        if (request_count > 0 && request_count < IMAGES_PER_REQUEST)
+                }
-                        {
+                if (gMessageSystem && sim_request_count > 0 && sim_request_count < IMAGES_PER_REQUEST)
-//                              llinfos << "REQUESTING " << request_count << " IMAGES FROM HOST: " << host.getIPString() << llendl;
+                {
-                                gMessageSystem->sendSemiReliable(host, NULL, NULL);
+//                      llinfos << "REQUESTING " << sim_request_count << " IMAGES FROM HOST: " << host.getIPString() << llendl;
-                                request_count = 0;
+                        gMessageSystem->sendSemiReliable(host, NULL, NULL);
-                        }
+                        sim_request_count = 0;
                }
        }
        
        // Send cancelations
-        if (!mCancelQueue.empty())
+        {
+        LLMutexLock lock2(&mNetworkQueueMutex);
+        if (gMessageSystem && !mCancelQueue.empty())
        {
                for (cancel_queue_t::iterator iter1 = mCancelQueue.begin();
                         iter1 != mCancelQueue.end(); ++iter1)
@@ -1732,6 +1863,7 @@ void LLTextureFetch::sendRequestListToSimulators()
                }
                mCancelQueue.clear();
        }
+        }
 }
 //////////////////////////////////////////////////////////////////////////////
@@ -1773,16 +1905,20 @@ bool LLTextureFetch::receiveImageHeader(const LLHost& host, const LLUUID& id, U8
 {
        LLMutexLock lock(&mQueueMutex);
        LLTextureFetchWorker* worker = getWorker(id);
-        bool res = true;
        ++mPacketCount;
        
        if (!worker)
        {
 //              llwarns << "Received header for non active worker: " << id << llendl;
-                res = false;
+                ++mBadPacketCount;
+                mCancelQueue[host].insert(id);
+                return false;
        }
-        else if (worker->mState != LLTextureFetchWorker::LOAD_FROM_NETWORK ||
+        bool res = true;
+        worker->lockWorkMutex();
+        if (worker->mState != LLTextureFetchWorker::LOAD_FROM_NETWORK ||
                         worker->mSentRequest != LLTextureFetchWorker::SENT_SIM)
        {
 //              llwarns << "receiveImageHeader for worker: " << id
@@ -1805,21 +1941,20 @@ bool LLTextureFetch::receiveImageHeader(const LLHost& host, const LLUUID& id, U8
        {
                ++mBadPacketCount;
                mCancelQueue[host].insert(id);
-                return false;
        }
+        else
-        worker->lockWorkData();
+        {
+                // Copy header data into image object
-        //      Copy header data into image object
+                worker->mImageCodec = codec;
-        worker->mImageCodec = codec;
+                worker->mTotalPackets = packets;
-        worker->mTotalPackets = packets;
+                worker->mFileSize = (S32)totalbytes;    
-        worker->mFileSize = (S32)totalbytes;    
+                llassert_always(totalbytes > 0);
-        llassert_always(totalbytes > 0);
+                llassert_always(data_size == FIRST_PACKET_SIZE || data_size == worker->mFileSize);
-        llassert_always(data_size == FIRST_PACKET_SIZE || data_size == worker->mFileSize);
+                res = worker->insertPacket(0, data, data_size);
-        res = worker->insertPacket(0, data, data_size);
+                worker->setPriority(LLWorkerThread::PRIORITY_HIGH | worker->mWorkPriority);
-        worker->setPriority(LLWorkerThread::PRIORITY_HIGH | worker->mWorkPriority);
+                worker->mState = LLTextureFetchWorker::LOAD_FROM_SIMULATOR;
-        worker->mState = LLTextureFetchWorker::LOAD_FROM_SIMULATOR;
+        }
-        worker->unlockWorkData();
+        worker->unlockWorkMutex();
        return res;
 }
@@ -1853,7 +1988,7 @@ bool LLTextureFetch::receiveImagePacket(const LLHost& host, const LLUUID& id, U1
                return false;
        }
-        worker->lockWorkData();
+        worker->lockWorkMutex();
        
        res = worker->insertPacket(packet_num, data, data_size);
        
@@ -1866,12 +2001,19 @@ bool LLTextureFetch::receiveImagePacket(const LLHost& host, const LLUUID& id, U1
        else
        {
 //              llwarns << "receiveImagePacket " << packet_num << "/" << worker->mLastPacket << " for worker: " << id
-//                      << " in state: " << LLTextureFetchWorker::sStateDescs[worker->mState] << llendl;
+//                              << " in state: " << LLTextureFetchWorker::sStateDescs[worker->mState] << llendl;
-                removeFromNetworkQueue(worker); // failsafe
-                mCancelQueue[host].insert(id);
        }
-        
-        worker->unlockWorkData();
+        if(packet_num >= (worker->mTotalPackets - 1))
+        {
+                if ((gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog")) || (gSavedSettings.getBOOL("LogTextureDownloadsToSimulator")))
+                {
+                        U64 timeNow = LLTimer::getTotalTime();
+                        mTextureInfo.setRequestSize(id, worker->mFileSize);
+                        mTextureInfo.setRequestCompleteTimeAndLog(id, timeNow);
+                }
+        }
+        worker->unlockWorkMutex();
        return res;
 }
@@ -1892,7 +2034,7 @@ S32 LLTextureFetch::getFetchState(const LLUUID& id, F32& data_progress_p, F32& r
        LLTextureFetchWorker* worker = getWorker(id);
        if (worker && worker->haveWork())
        {
-                worker->lockWorkData();
+                worker->lockWorkMutex();
                state = worker->mState;
                fetch_dtime = worker->mFetchTimer.getElapsedTimeF32();
                request_dtime = worker->mRequestedTimer.getElapsedTimeF32();
@@ -1909,7 +2051,7 @@ S32 LLTextureFetch::getFetchState(const LLUUID& id, F32& data_progress_p, F32& r
                                data_progress = (F32)worker->mFormattedImage->getDataSize() / (F32)worker->mFileSize;
                        }
                }
-                if (state >= LLTextureFetchWorker::LOAD_FROM_NETWORK && state <= LLTextureFetchWorker::LOAD_FROM_HTTP_GET_DATA)
+                if (state >= LLTextureFetchWorker::LOAD_FROM_NETWORK && state <= LLTextureFetchWorker::WAIT_HTTP_REQ)
                {
                        requested_priority = worker->mRequestedPriority;
                }
@@ -1918,7 +2060,7 @@ S32 LLTextureFetch::getFetchState(const LLUUID& id, F32& data_progress_p, F32& r
                        requested_priority = worker->mImagePriority;
                }
                fetch_priority = worker->getPriority();
-                worker->unlockWorkData();
+                worker->unlockWorkMutex();
        }
        data_progress_p = data_progress;
        requested_priority_p = requested_priority;
@@ -1944,5 +2086,3 @@ void LLTextureFetch::dump()
        }
 }
-//////////////////////////////////////////////////////////////////////////////
diff --git a/linden/indra/newview/lltexturefetch.h b/linden/indra/newview/lltexturefetch.h
index 56650e7..c48f609 100644
--- a/linden/indra/newview/lltexturefetch.h
+++ b/linden/indra/newview/lltexturefetch.h
@@ -37,26 +37,29 @@
 #include "llimage.h"
 #include "lluuid.h"
 #include "llworkerthread.h"
+#include "llcurl.h"
+#include "lltextureinfo.h"
 class LLViewerImage;
 class LLTextureFetchWorker;
+class HTTPGetResponder;
 class LLTextureCache;
+class LLImageDecodeThread;
 class LLHost;
 // Interface class
 class LLTextureFetch : public LLWorkerThread
 {
        friend class LLTextureFetchWorker;
+        friend class HTTPGetResponder;
        
 public:
-        LLTextureFetch(LLTextureCache* cache, bool threaded);
+        LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* imagedecodethread, bool threaded);
        ~LLTextureFetch();
        /*virtual*/ S32 update(U32 max_time_ms);        
-        bool createRequest(const LLUUID& id, const LLHost& host, F32 priority,
+        bool createRequest(const std::string& url, const LLUUID& id, const LLHost& host, F32 priority,
-                                           S32 w, S32 h, S32 c, S32 discard, bool needs_aux);
-        bool createRequest(const std::string& filename, const LLUUID& id, const LLHost& host, F32 priority,
                                           S32 w, S32 h, S32 c, S32 discard, bool needs_aux);
        void deleteRequest(const LLUUID& id, bool cancel);
        bool getRequestFinished(const LLUUID& id, S32& discard_level,
@@ -66,24 +69,38 @@ public:
        bool receiveImageHeader(const LLHost& host, const LLUUID& id, U8 codec, U16 packets, U32 totalbytes, U16 data_size, U8* data);
        bool receiveImagePacket(const LLHost& host, const LLUUID& id, U16 packet_num, U16 data_size, U8* data);
+        void setTextureBandwidth(F32 bandwidth) { mTextureBandwidth = bandwidth; }
+        F32 getTextureBandwidth() { return mTextureBandwidth; }
+        
        // Debug
        S32 getFetchState(const LLUUID& id, F32& decode_progress_p, F32& requested_priority_p,
                                          U32& fetch_priority_p, F32& fetch_dtime_p, F32& request_dtime_p);
        void dump();
        S32 getNumRequests() { return mRequestMap.size(); }
+        S32 getNumHTTPRequests() { return mHTTPTextureQueue.size(); }
        
        // Public for access by callbacks
        void lockQueue() { mQueueMutex.lock(); }
        void unlockQueue() { mQueueMutex.unlock(); }
        LLTextureFetchWorker* getWorker(const LLUUID& id);
+        LLTextureInfo* getTextureInfo() { return &mTextureInfo; }
        
 protected:
        void addToNetworkQueue(LLTextureFetchWorker* worker);
-        void removeFromNetworkQueue(LLTextureFetchWorker* worker);
+        void removeFromNetworkQueue(LLTextureFetchWorker* worker, bool cancel);
+        void addToHTTPQueue(const LLUUID& id);
+        void removeFromHTTPQueue(const LLUUID& id);
+        S32 getHTTPQueueSize() { return (S32)mHTTPTextureQueue.size(); }
        void removeRequest(LLTextureFetchWorker* worker, bool cancel);
+        // Called from worker thread (during doWork)
+        void processCurlRequests();     
 private:
        void sendRequestListToSimulators();
+        /*virtual*/ void startThread(void);
+        /*virtual*/ void endThread(void);
+        /*virtual*/ void threadedUpdate(void);
 public:
        LLUUID mDebugID;
@@ -94,8 +111,11 @@ public:
        
 private:
        LLMutex mQueueMutex;
+        LLMutex mNetworkQueueMutex;
        LLTextureCache* mTextureCache;
+        LLImageDecodeThread* mImageDecodeThread;
+        LLCurlRequest* mCurlGetRequest;
        
        // Map of all requests by UUID
        typedef std::map<LLUUID,LLTextureFetchWorker*> map_t;
@@ -104,10 +124,13 @@ private:
        // Set of requests that require network data
        typedef std::set<LLUUID> queue_t;
        queue_t mNetworkQueue;
+        queue_t mHTTPTextureQueue;
        typedef std::map<LLHost,std::set<LLUUID> > cancel_queue_t;
        cancel_queue_t mCancelQueue;
+        F32 mTextureBandwidth;
-        LLFrameTimer mNetworkTimer;
+        F32 mMaxBandwidth;
+        LLTextureInfo mTextureInfo;
 };
 #endif // LL_LLTEXTUREFETCH_H
diff --git a/linden/indra/newview/lltextureinfo.cpp b/linden/indra/newview/lltextureinfo.cpp
new file mode 100644
index 0000000..672a36a
--- /dev/null
+++ b/linden/indra/newview/lltextureinfo.cpp
@@ -0,0 +1,290 @@
+/** 
+ * @file lltextureinfo.cpp
+ * @brief Object which handles local texture info
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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$
+ */
+#include "llviewerprecompiledheaders.h"
+#include "lltextureinfo.h"
+#include "lltexturestats.h"
+#include "llviewercontrol.h"
+LLTextureInfo::LLTextureInfo() : 
+        mLogTextureDownloadsToViewerLog(false),
+        mLogTextureDownloadsToSimulator(false),
+        mTotalBytes(0),
+        mTotalMilliseconds(0),
+        mTextureDownloadsStarted(0),
+        mTextureDownloadsCompleted(0),
+        mTextureDownloadProtocol("NONE"),
+        mTextureLogThreshold(100 * 1024),
+        mCurrentStatsBundleStartTime(0)
+{
+        mTextures.clear();
+}
+void LLTextureInfo::setUpLogging(bool writeToViewerLog, bool sendToSim, U32 textureLogThreshold)
+{
+        mLogTextureDownloadsToViewerLog = writeToViewerLog;
+        mLogTextureDownloadsToSimulator = sendToSim;
+        mTextureLogThreshold = textureLogThreshold;
+}
+LLTextureInfo::~LLTextureInfo()
+{
+        std::map<LLUUID, LLTextureInfoDetails *>::iterator iterator;
+        for (iterator = mTextures.begin(); iterator != mTextures.end(); iterator++)
+        {
+                LLTextureInfoDetails *info = (*iterator).second;
+                delete info;
+        }
+        mTextures.clear();
+}
+void LLTextureInfo::addRequest(const LLUUID& id)
+{
+        LLTextureInfoDetails *info = new LLTextureInfoDetails();
+        mTextures[id] = info;
+}
+U32 LLTextureInfo::getTextureInfoMapSize()
+{
+        return mTextures.size();
+}
+bool LLTextureInfo::has(const LLUUID& id)
+{
+        std::map<LLUUID, LLTextureInfoDetails *>::iterator iterator = mTextures.find(id);
+        if (iterator == mTextures.end())
+        {
+                return false;
+        }
+        else
+        {
+                return true;
+        }
+}
+void LLTextureInfo::setRequestStartTime(const LLUUID& id, U64 startTime)
+{
+        if (!has(id))
+        {
+                addRequest(id);
+        }
+        mTextures[id]->mStartTime = startTime;
+        mTextureDownloadsStarted++;
+}
+void LLTextureInfo::setRequestSize(const LLUUID& id, U32 size)
+{
+        if (!has(id))
+        {
+                addRequest(id);
+        }
+        mTextures[id]->mSize = size;
+}
+void LLTextureInfo::setRequestOffset(const LLUUID& id, U32 offset)
+{
+        if (!has(id))
+        {
+                addRequest(id);
+        }
+        mTextures[id]->mOffset = offset;
+}
+void LLTextureInfo::setRequestType(const LLUUID& id, LLTextureInfoDetails::LLRequestType type)
+{
+        if (!has(id))
+        {
+                addRequest(id);
+        }
+        mTextures[id]->mType = type;
+}
+void LLTextureInfo::setRequestCompleteTimeAndLog(const LLUUID& id, U64 completeTime)
+{
+        if (!has(id))
+        {
+                addRequest(id);
+        }
+        mTextures[id]->mCompleteTime = completeTime;
+        std::string protocol = "NONE";
+        switch(mTextures[id]->mType)
+        {
+        case LLTextureInfoDetails::REQUEST_TYPE_HTTP:
+                protocol = "HTTP";
+                break;
+        case LLTextureInfoDetails::REQUEST_TYPE_UDP:
+                protocol = "UDP";
+                break;
+        case LLTextureInfoDetails::REQUEST_TYPE_NONE:
+        default:
+                break;
+        }
+        if (mLogTextureDownloadsToViewerLog)
+        {
+                llinfos << "texture=" << id 
+                        << " start=" << mTextures[id]->mStartTime 
+                        << " end=" << mTextures[id]->mCompleteTime
+                        << " size=" << mTextures[id]->mSize
+                        << " offset=" << mTextures[id]->mOffset
+                        << " length_in_ms=" << (mTextures[id]->mCompleteTime - mTextures[id]->mStartTime) / 1000
+                        << " protocol=" << protocol
+                        << llendl;
+        }
+        if(mLogTextureDownloadsToSimulator)
+        {
+                S32 texture_stats_upload_threshold = mTextureLogThreshold;
+                mTotalBytes += mTextures[id]->mSize;
+                mTotalMilliseconds += mTextures[id]->mCompleteTime - mTextures[id]->mStartTime;
+                mTextureDownloadsCompleted++;
+                mTextureDownloadProtocol = protocol;
+                if (mTotalBytes >= texture_stats_upload_threshold)
+                {
+                        LLSD texture_data;
+                        std::stringstream startTime;
+                        startTime << mCurrentStatsBundleStartTime;
+                        texture_data["start_time"] = startTime.str();
+                        std::stringstream endTime;
+                        endTime << completeTime;
+                        texture_data["end_time"] = endTime.str();
+                        texture_data["averages"] = getAverages();
+                        send_texture_stats_to_sim(texture_data);
+                        resetTextureStatistics();
+                }
+        }
+        mTextures.erase(id);
+}
+LLSD LLTextureInfo::getAverages()
+{
+        LLSD averagedTextureData;
+        S32 averageDownloadRate;
+        if(mTotalMilliseconds == 0)
+        {
+                averageDownloadRate = 0;
+        }
+        else
+        {
+                averageDownloadRate = (mTotalBytes * 8) / mTotalMilliseconds;
+        }
+        averagedTextureData["bits_per_second"] = averageDownloadRate;
+        averagedTextureData["bytes_downloaded"] = mTotalBytes;
+        averagedTextureData["texture_downloads_started"] = mTextureDownloadsStarted;
+        averagedTextureData["texture_downloads_completed"] = mTextureDownloadsCompleted;
+        averagedTextureData["transport"] = mTextureDownloadProtocol;
+        return averagedTextureData;
+}
+void LLTextureInfo::resetTextureStatistics()
+{
+        mTotalMilliseconds = 0;
+        mTotalBytes = 0;
+        mTextureDownloadsStarted = 0;
+        mTextureDownloadsCompleted = 0;
+        mTextureDownloadProtocol = "NONE";
+        mCurrentStatsBundleStartTime = LLTimer::getTotalTime();
+}
+U32 LLTextureInfo::getRequestStartTime(const LLUUID& id)
+{
+        if (!has(id))
+        {
+                return 0;
+        }
+        else
+        {
+                std::map<LLUUID, LLTextureInfoDetails *>::iterator iterator = mTextures.find(id);
+                return (*iterator).second->mStartTime;
+        }
+}
+U32 LLTextureInfo::getRequestSize(const LLUUID& id)
+{
+        if (!has(id))
+        {
+                return 0;
+        }
+        else
+        {
+                std::map<LLUUID, LLTextureInfoDetails *>::iterator iterator = mTextures.find(id);
+                return (*iterator).second->mSize;
+        }
+}
+U32 LLTextureInfo::getRequestOffset(const LLUUID& id)
+{
+        if (!has(id))
+        {
+                return 0;
+        }
+        else
+        {
+                std::map<LLUUID, LLTextureInfoDetails *>::iterator iterator = mTextures.find(id);
+                return (*iterator).second->mOffset;
+        }
+}
+LLTextureInfoDetails::LLRequestType LLTextureInfo::getRequestType(const LLUUID& id)
+{
+        if (!has(id))
+        {
+                return LLTextureInfoDetails::REQUEST_TYPE_NONE;
+        }
+        else
+        {
+                std::map<LLUUID, LLTextureInfoDetails *>::iterator iterator = mTextures.find(id);
+                return (*iterator).second->mType;
+        }
+}
+U32 LLTextureInfo::getRequestCompleteTime(const LLUUID& id)
+{
+        if (!has(id))
+        {
+                return 0;
+        }
+        else
+        {
+                std::map<LLUUID, LLTextureInfoDetails *>::iterator iterator = mTextures.find(id);
+                return (*iterator).second->mCompleteTime;
+        }
+}
diff --git a/linden/indra/newview/lltextureinfo.h b/linden/indra/newview/lltextureinfo.h
new file mode 100644
index 0000000..71b0ea4
--- /dev/null
+++ b/linden/indra/newview/lltextureinfo.h
@@ -0,0 +1,80 @@
+/** 
+ * @file lltextureinfo.h
+ * @brief Object for managing texture information.
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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_LLTEXTUREINFO_H
+#define LL_LLTEXTUREINFO_H
+#include "lluuid.h"
+#include "lltextureinfodetails.h"
+#include <map>
+class LLTextureInfo
+{
+public:
+        LLTextureInfo();
+        ~LLTextureInfo();
+        void setUpLogging(bool writeToViewerLog, bool sendToSim, U32 textureLogThreshold);
+        bool has(const LLUUID& id);
+        void setRequestStartTime(const LLUUID& id, U64 startTime);
+        void setRequestSize(const LLUUID& id, U32 size);
+        void setRequestOffset(const LLUUID& id, U32 offset);
+        void setRequestType(const LLUUID& id, LLTextureInfoDetails::LLRequestType type);
+        void setRequestCompleteTimeAndLog(const LLUUID& id, U64 completeTime);
+        U32 getRequestStartTime(const LLUUID& id);
+        U32 getRequestSize(const LLUUID& id);
+        U32 getRequestOffset(const LLUUID& id);
+        LLTextureInfoDetails::LLRequestType getRequestType(const LLUUID& id);
+        U32 getRequestCompleteTime(const LLUUID& id);
+        void resetTextureStatistics();
+        U32 getTextureInfoMapSize();
+        LLSD getAverages();
+private:
+        void addRequest(const LLUUID& id);
+        std::map<LLUUID, LLTextureInfoDetails *> mTextures;
+        LLSD mAverages;
+        bool mLogTextureDownloadsToViewerLog;
+        bool mLogTextureDownloadsToSimulator;
+        S32 mTotalBytes;
+        S32 mTotalMilliseconds;
+        S32 mTextureDownloadsStarted;
+        S32 mTextureDownloadsCompleted;
+        std::string mTextureDownloadProtocol;
+        U32 mTextureLogThreshold; // in bytes
+        U64 mCurrentStatsBundleStartTime;
+};
+#endif // LL_LLTEXTUREINFO_H
diff --git a/linden/indra/newview/lltextureinfodetails.cpp b/linden/indra/newview/lltextureinfodetails.cpp
new file mode 100644
index 0000000..f6ef47a
--- /dev/null
+++ b/linden/indra/newview/lltextureinfodetails.cpp
@@ -0,0 +1,40 @@
+/** 
+ * @file lltextureinfodetails.cpp
+ * @brief Object which handles details of any individual texture
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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$
+ */
+#include "llviewerprecompiledheaders.h"
+#include "lltextureinfodetails.h"
+LLTextureInfoDetails::LLTextureInfoDetails() : mStartTime(0), mCompleteTime(0), mSize(0), mType(REQUEST_TYPE_NONE), mOffset(0)
+{
+}
diff --git a/linden/indra/newview/lltextureinfodetails.h b/linden/indra/newview/lltextureinfodetails.h
new file mode 100644
index 0000000..091fa01
--- /dev/null
+++ b/linden/indra/newview/lltextureinfodetails.h
@@ -0,0 +1,58 @@
+/** 
+ * @file lltextureinfo.h
+ * @brief Object for managing texture information.
+ *
+ * $LicenseInfo:firstyear=2000&license=viewergpl$
+ * 
+ * Copyright (c) 2000-2009, 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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_LLTEXTUREINFODETAILS_H
+#define LL_LLTEXTUREINFODETAILS_H
+#include "lluuid.h"
+class LLTextureInfoDetails
+{
+public:
+        enum LLRequestType
+        {
+                REQUEST_TYPE_NONE,
+                REQUEST_TYPE_HTTP,
+                REQUEST_TYPE_UDP
+        };
+        U32 mStartTime;
+        U32 mCompleteTime;
+        U32 mOffset;
+        U32 mSize;
+        LLRequestType mType;
+        LLTextureInfoDetails();
+};
+#endif // LL_LLTEXTUREINFODETAILS_H
diff --git a/linden/indra/newview/lltexturestats.cpp b/linden/indra/newview/lltexturestats.cpp
new file mode 100644
index 0000000..c91bfd4
--- /dev/null
+++ b/linden/indra/newview/lltexturestats.cpp
@@ -0,0 +1,61 @@
+/** 
+ * @file lltexturerstats.cpp
+ * @brief texture stats helper methods
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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$
+ */
+#include "llviewerprecompiledheaders.h"
+#include "pipeline.h" 
+#include "llagent.h"
+#include "lltexturefetch.h" 
+#include "lltexturestats.h"
+#include "lltexturestatsuploader.h"
+#include "llviewerregion.h"
+void send_texture_stats_to_sim(const LLSD &texture_stats)
+{
+        LLSD texture_stats_report;
+        // Only send stats if the agent is connected to a region.
+        if (!gAgent.getRegion() || gNoRender)
+        {
+                return;
+        }
+        LLUUID agent_id = gAgent.getID();
+        texture_stats_report["agent_id"] = agent_id;
+        texture_stats_report["region_id"] = gAgent.getRegion()->getRegionID();
+        texture_stats_report["stats_data"] = texture_stats;
+        std::string texture_cap_url = gAgent.getRegion()->getCapability("TextureStats");
+        LLTextureStatsUploader tsu;
+        llinfos << "uploading texture stats data to simulator" << llendl;
+        tsu.uploadStatsToSimulator(texture_cap_url, texture_stats);
+}
diff --git a/linden/indra/newview/lltexturestats.h b/linden/indra/newview/lltexturestats.h
new file mode 100644
index 0000000..2deb377
--- /dev/null
+++ b/linden/indra/newview/lltexturestats.h
@@ -0,0 +1,41 @@
+/** 
+ * @file lltexturestats.h
+ * @brief texture stats utilities
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 2009, 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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_LLTEXTURESTATS_H
+#define LL_LLTEXTURESTATS_H
+#include "llappviewer.h"
+// utility functions to capture data on texture download speeds and send to simulator periodically
+void send_texture_stats_to_sim(const LLSD &texture_stats);
+#endif // LL_LLTEXTURESTATS_H
diff --git a/linden/indra/newview/lltexturestatsuploader.cpp b/linden/indra/newview/lltexturestatsuploader.cpp
new file mode 100644
index 0000000..e0358e1
--- /dev/null
+++ b/linden/indra/newview/lltexturestatsuploader.cpp
@@ -0,0 +1,59 @@
+/** 
+ * @file lltexturerstats.cpp
+ * @brief texture stats upload class
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2009, 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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$
+ */
+#include "llviewerprecompiledheaders.h"
+#include "lltexturestatsuploader.h"
+LLTextureStatsUploader::LLTextureStatsUploader()
+{
+}
+LLTextureStatsUploader::~LLTextureStatsUploader()
+{
+}
+void LLTextureStatsUploader::uploadStatsToSimulator(const std::string texture_cap_url, const LLSD &texture_stats)
+{
+        if ( texture_cap_url != "" )
+        {
+                LLHTTPClient::post(texture_cap_url, texture_stats, NULL);
+        }
+        else
+        {
+                llinfos << "Not sending texture stats: " 
+                                << texture_stats 
+                                << " as there is no cap url." 
+                                << llendl;
+        }
+}
diff --git a/linden/indra/newview/lltexturestatsuploader.h b/linden/indra/newview/lltexturestatsuploader.h
new file mode 100644
index 0000000..f6cc8be
--- /dev/null
+++ b/linden/indra/newview/lltexturestatsuploader.h
@@ -0,0 +1,48 @@
+/** 
+ * @file lltexturestatsuploader.h
+ * @brief Class to send the texture stats to the simulatore
+ *
+ * $LicenseInfo:firstyear=2009&license=viewergpl$
+ * 
+ * Copyright (c) 2009, 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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_LLTEXTURESTATSUPLOADER_H
+#define LL_LLTEXTURESTATSUPLOADER_H
+#include "llappviewer.h"
+// utility functions to capture data on texture download speeds and send to simulator periodically
+class LLTextureStatsUploader
+{
+public:
+        LLTextureStatsUploader();
+        ~LLTextureStatsUploader();
+        void uploadStatsToSimulator(const std::string texture_cap_url, const LLSD &texture_stats);
+};
+#endif // LL_LLTEXTURESTATSUPLOADER_H
diff --git a/linden/indra/newview/lltextureview.cpp b/linden/indra/newview/lltextureview.cpp
index d356bf9..b6159da 100644
--- a/linden/indra/newview/lltextureview.cpp
+++ b/linden/indra/newview/lltextureview.cpp
@@ -43,16 +43,17 @@
 #include "llimageworker.h"
 #include "llrender.h"
+#include "llappviewer.h"
 #include "llhoverview.h"
 #include "llselectmgr.h"
 #include "lltexlayer.h"
 #include "lltexturecache.h"
 #include "lltexturefetch.h"
+#include "llviewercontrol.h"
 #include "llviewerobject.h"
 #include "llviewerimage.h"
 #include "llviewerimagelist.h"
-#include "llappviewer.h"
+#include "llvovolume.h"
 extern F32 texmem_lower_bound_scale;
 LLTextureView *gTextureView = NULL;
@@ -466,9 +467,9 @@ void LLGLTexMemBar::draw()
                                        LLAppViewer::getTextureFetch()->mPacketCount, LLAppViewer::getTextureFetch()->mBadPacketCount, 
                                        LLAppViewer::getTextureCache()->getNumReads(), LLAppViewer::getTextureCache()->getNumWrites(),
                                        LLLFSThread::sLocal->getPending(),
-                                        LLImageWorker::sCount, LLImageWorker::getWorkerThread()->getNumDeletes(),
+                                        LLAppViewer::getImageDecodeThread()->getPending(), 
-                                        LLImageRaw::sRawImageCount, LLViewerImage::sRawCount, LLViewerImage::sAuxCount,
+                                        LLImageRaw::sRawImageCount,
-                                        gImageList.mCallbackList.size());
+                                        LLAppViewer::getTextureFetch()->getNumHTTPRequests());
        LLFontGL::getFontMonospace()->renderUTF8(text, 0, 0, line_height*2,
                                                                         text_color, LLFontGL::LEFT, LLFontGL::TOP);
diff --git a/linden/indra/newview/llviewercamera.cpp b/linden/indra/newview/llviewercamera.cpp
index 72d1494..dade65f 100644
--- a/linden/indra/newview/llviewercamera.cpp
+++ b/linden/indra/newview/llviewercamera.cpp
@@ -102,10 +102,13 @@ LLViewerCamera::LLViewerCamera() : LLCamera()
 {
        calcProjection(getFar());
        mCameraFOVDefault = DEFAULT_FIELD_OF_VIEW;
+        mCosHalfCameraFOV = cosf(mCameraFOVDefault * 0.5f);
        mPixelMeterRatio = 0.f;
        mScreenPixelArea = 0;
        mZoomFactor = 1.f;
        mZoomSubregion = 1;
+        mAverageSpeed = 0.f;
+        mAverageAngularSpeed = 0.f;
 }
 void LLViewerCamera::updateCameraLocation(const LLVector3 &center,
@@ -144,15 +147,22 @@ void LLViewerCamera::updateCameraLocation(const LLVector3 &center,
        setOriginAndLookAt(origin, up_direction, point_of_interest);
-        F32 dpos = (center - last_position).magVec();
+        mVelocityDir = center - last_position ; 
+        F32 dpos = mVelocityDir.normVec() ;
        LLQuaternion rotation;
        rotation.shortestArc(last_axis, getAtAxis());
        F32 x, y, z;
        F32 drot;
        rotation.getAngleAxis(&drot, &x, &y, &z);
        mVelocityStat.addValue(dpos);
        mAngularVelocityStat.addValue(drot);
+        
+        mAverageSpeed = mVelocityStat.getMeanPerSec() ;
+        mAverageAngularSpeed = mAngularVelocityStat.getMeanPerSec() ;
+        mCosHalfCameraFOV = cosf(0.5f * getView() * llmax(1.0f, getAspect()));
        // update pixel meter ratio using default fov, not modified one
        mPixelMeterRatio = getViewHeightInPixels()/ (2.f*tanf(mCameraFOVDefault*0.5));
        // update screen pixel area
@@ -759,8 +769,8 @@ BOOL LLViewerCamera::areVertsVisible(LLViewerObject* volumep, BOOL all_verts)
                        BOOL in_frustum = pointInFrustum(LLVector3(vec)) > 0;
-                        if ( !in_frustum && all_verts ||
+                        if (( !in_frustum && all_verts) ||
-                                 in_frustum && !all_verts)
+                                 (in_frustum && !all_verts))
                        {
                                return !all_verts;
                        }
@@ -797,9 +807,11 @@ BOOL LLViewerCamera::areVertsVisible(LLViewerObject* volumep, BOOL all_verts)
        LLCamera::setView(vertical_fov_rads); // call base implementation
 }
-void LLViewerCamera::setDefaultFOV(F32 vertical_fov_rads) {
+void LLViewerCamera::setDefaultFOV(F32 vertical_fov_rads) 
+{
        vertical_fov_rads = llclamp(vertical_fov_rads, getMinView(), getMaxView());
        setView(vertical_fov_rads);
        mCameraFOVDefault = vertical_fov_rads; 
+        mCosHalfCameraFOV = cosf(mCameraFOVDefault * 0.5f);
 }
diff --git a/linden/indra/newview/llviewercamera.h b/linden/indra/newview/llviewercamera.h
index 6a0c42b..d25d063 100644
--- a/linden/indra/newview/llviewercamera.h
+++ b/linden/indra/newview/llviewercamera.h
@@ -71,17 +71,20 @@ public:
        BOOL projectPosAgentToScreen(const LLVector3 &pos_agent, LLCoordGL &out_point, const BOOL clamp = TRUE) const;
        BOOL projectPosAgentToScreenEdge(const LLVector3 &pos_agent, LLCoordGL &out_point) const;
+        const LLVector3* getVelocityDir() const {return &mVelocityDir;}
        LLStat *getVelocityStat() { return &mVelocityStat; }
        LLStat *getAngularVelocityStat() { return &mAngularVelocityStat; }
+        F32     getCosHalfFov() {return mCosHalfCameraFOV;}
+        F32     getAverageSpeed() {return mAverageSpeed ;}
+        F32     getAverageAngularSpeed() {return mAverageAngularSpeed;}
        void getPixelVectors(const LLVector3 &pos_agent, LLVector3 &up, LLVector3 &right);
        LLVector3 roundToPixel(const LLVector3 &pos_agent);
        // Sets the current matrix
        /* virtual */ void setView(F32 vertical_fov_rads);
-        // Sets the current matrix AND remembers result as default view
-        void setDefaultFOV(F32 vertical_fov_rads);
+        void setDefaultFOV(F32 fov) ;
        F32 getDefaultFOV() { return mCameraFOVDefault; }
        BOOL cameraUnderWater() const;
@@ -100,9 +103,14 @@ protected:
        LLStat mVelocityStat;
        LLStat mAngularVelocityStat;
+        LLVector3 mVelocityDir ;
+        F32       mAverageSpeed ;
+        F32       mAverageAngularSpeed ;
        mutable LLMatrix4       mProjectionMatrix;      // Cache of perspective matrix
        mutable LLMatrix4       mModelviewMatrix;
        F32                                     mCameraFOVDefault;
+        F32                                     mCosHalfCameraFOV;
        LLVector3                       mLastPointOfInterest;
        F32                                     mPixelMeterRatio; // Divide by distance from camera to get pixels per meter at that distance.
        S32                                     mScreenPixelArea; // Pixel area of entire window
diff --git a/linden/indra/newview/llviewercontrol.cpp b/linden/indra/newview/llviewercontrol.cpp
index 08e9d45..6d62db5 100644
--- a/linden/indra/newview/llviewercontrol.cpp
+++ b/linden/indra/newview/llviewercontrol.cpp
@@ -91,6 +91,8 @@ std::string gCurrentVersion;
 extern BOOL gResizeScreenTexture;
 extern BOOL gDebugGL;
+extern BOOL gAuditTexture;
 ////////////////////////////////////////////////////////////////////////////
 // Listeners
@@ -374,6 +376,12 @@ static bool handleRenderUseImpostorsChanged(const LLSD& newvalue)
        return true;
 }
+static bool handleAuditTextureChanged(const LLSD& newvalue)
+{
+        gAuditTexture = newvalue.asBoolean();
+        return true;
+}
 static bool handleRenderDebugGLChanged(const LLSD& newvalue)
 {
        gDebugGL = newvalue.asBoolean();
@@ -527,6 +535,7 @@ void settings_setup_listeners()
        gSavedSettings.getControl("AudioLevelDoppler")->getSignal()->connect(boost::bind(&handleAudioVolumeChanged, _1));
        gSavedSettings.getControl("AudioLevelRolloff")->getSignal()->connect(boost::bind(&handleAudioVolumeChanged, _1));
        gSavedSettings.getControl("AudioStreamingMusic")->getSignal()->connect(boost::bind(&handleAudioStreamMusicChanged, _1));
+        gSavedSettings.getControl("AuditTexture")->getSignal()->connect(boost::bind(&handleAuditTextureChanged, _1));
        gSavedSettings.getControl("MuteAudio")->getSignal()->connect(boost::bind(&handleAudioVolumeChanged, _1));
        gSavedSettings.getControl("MuteMusic")->getSignal()->connect(boost::bind(&handleAudioVolumeChanged, _1));
        gSavedSettings.getControl("MuteMedia")->getSignal()->connect(boost::bind(&handleAudioVolumeChanged, _1));
diff --git a/linden/indra/newview/llviewerimage.cpp b/linden/indra/newview/llviewerimage.cpp
index 272fcb5..3a14bf0 100644
--- a/linden/indra/newview/llviewerimage.cpp
+++ b/linden/indra/newview/llviewerimage.cpp
@@ -59,6 +59,8 @@
 #include "llviewercontrol.h"
 #include "pipeline.h"
 #include "llappviewer.h"
+#include "llface.h"
+#include "llviewercamera.h"
 ///////////////////////////////////////////////////////////////////////////////
 // statics
@@ -72,6 +74,7 @@ S32 LLViewerImage::sImageCount = 0;
 S32 LLViewerImage::sRawCount = 0;
 S32 LLViewerImage::sAuxCount = 0;
 LLTimer LLViewerImage::sEvaluationTimer;
+S8  LLViewerImage::sCameraMovingDiscardBias = 0 ;
 F32 LLViewerImage::sDesiredDiscardBias = 0.f;
 static F32 sDesiredDiscardBiasMin = -2.0f; // -max number of levels to improve image quality by
 static F32 sDesiredDiscardBiasMax = 1.5f; // max number of levels to reduce image quality by
@@ -83,16 +86,26 @@ S32 LLViewerImage::sMaxTotalTextureMemInMegaBytes = 0;
 S32 LLViewerImage::sMaxDesiredTextureMemInBytes = 0 ;
 BOOL LLViewerImage::sDontLoadVolumeTextures = FALSE;
+S32 LLViewerImage::sMaxSculptRez = 128 ; //max sculpt image size
+const S32 MAX_CACHED_RAW_IMAGE_AREA = 64 * 64 ;
+const S32 MAX_CACHED_RAW_SCULPT_IMAGE_AREA = LLViewerImage::sMaxSculptRez * LLViewerImage::sMaxSculptRez ;
+const S32 MAX_CACHED_RAW_TERRAIN_IMAGE_AREA = 128 * 128 ;
+S32 LLViewerImage::sMinLargeImageSize = 65536 ; //256 * 256.
+S32 LLViewerImage::sMaxSmallImageSize = MAX_CACHED_RAW_IMAGE_AREA ;
+BOOL LLViewerImage::sFreezeImageScalingDown = FALSE ;
+//debug use
+S32 LLViewerImage::sLLViewerImageCount = 0 ;
 // static
 void LLViewerImage::initClass()
-{
+{       
        sNullImagep = new LLImageGL(1,1,3,TRUE);
        LLPointer<LLImageRaw> raw = new LLImageRaw(1,1,3);
        raw->clear(0x77, 0x77, 0x77, 0xFF);
-        sNullImagep->createGLTexture(0, raw);
+        sNullImagep->createGLTexture(0, raw, 0, TRUE, LLViewerImageBoostLevel::OTHER);
 #if 1
-        LLPointer<LLViewerImage> imagep = new LLViewerImage(IMG_DEFAULT, TRUE);
+        LLPointer<LLViewerImage> imagep = new LLViewerImage(IMG_DEFAULT);
        sDefaultImagep = imagep;
        const S32 dim = 128;
        LLPointer<LLImageRaw> image_raw = new LLImageRaw(dim,dim,3);
@@ -118,7 +131,7 @@ void LLViewerImage::initClass()
                        }
                }
        }
-        imagep->createGLTexture(0, image_raw);
+        imagep->createGLTexture(0, image_raw, 0, TRUE, LLViewerImageBoostLevel::OTHER);
        image_raw = NULL;
        gImageList.addImage(imagep);
        imagep->dontDiscard();
@@ -128,17 +141,48 @@ void LLViewerImage::initClass()
        sSmokeImagep = gImageList.getImage(IMG_SMOKE, TRUE, TRUE);
        sSmokeImagep->setNoDelete() ;
+        if(gAuditTexture)
+        {
+                sDefaultTexturep = new LLImageGL() ;
+                image_raw = new LLImageRaw(dim,dim,3);
+                data = image_raw->getData();
+                for (S32 i = 0; i<dim; i++)
+                {
+                        for (S32 j = 0; j<dim; j++)
+                        {
+                                const S32 border = 2;
+                                if (i<border || j<border || i>=(dim-border) || j>=(dim-border))
+                                {
+                                        *data++ = 0xff;
+                                        *data++ = 0xff;
+                                        *data++ = 0xff;
+                                }
+                                else
+                                {
+                                        *data++ = 0xff;
+                                        *data++ = 0xff;
+                                        *data++ = 0x00;
+                                }
+                        }
+                }
+                sDefaultTexturep->createGLTexture(0, image_raw, 0, TRUE, LLViewerImageBoostLevel::OTHER);
+                image_raw = NULL;
+                sDefaultTexturep->dontDiscard();
+        }
 }
 // static
 void LLViewerImage::cleanupClass()
 {
        stop_glerror();
+        LLImageGL::cleanupClass() ;
        sNullImagep = NULL;
        sDefaultImagep = NULL;
        sSmokeImagep = NULL;
        sMissingAssetImagep = NULL;
-        sWhiteImagep = NULL;
+        sWhiteImagep = NULL;    
+        sDefaultTexturep = NULL ;
 }
 // tuning params
@@ -186,6 +230,13 @@ void LLViewerImage::updateClass(const F32 velocity, const F32 angular_velocity)
                }
        }
        sDesiredDiscardBias = llclamp(sDesiredDiscardBias, sDesiredDiscardBiasMin, sDesiredDiscardBiasMax);
+        F32 camera_moving_speed = LLViewerCamera::getInstance()->getAverageSpeed() ;
+        F32 camera_angular_speed = LLViewerCamera::getInstance()->getAverageAngularSpeed();
+        sCameraMovingDiscardBias = (S8)llmax(0.2f * camera_moving_speed, 2.0f * camera_angular_speed - 1) ;
+        LLViewerImage::sFreezeImageScalingDown = (BYTES_TO_MEGA_BYTES(sBoundTextureMemoryInBytes) < 0.75f * sMaxBoundTextureMemInMegaBytes * texmem_middle_bound_scale) &&
+                                (BYTES_TO_MEGA_BYTES(sTotalTextureMemoryInBytes) < 0.75f * sMaxTotalTextureMemInMegaBytes * texmem_middle_bound_scale) ;
 }
 // static
@@ -198,18 +249,19 @@ LLViewerImage* LLViewerImage::getImage(const LLUUID& image_id)
 const U32 LLViewerImage::sCurrentFileVersion = 1;
-LLViewerImage::LLViewerImage(const LLUUID& id, BOOL usemipmaps)
+LLViewerImage::LLViewerImage(const LLUUID& id, const LLHost& host, BOOL usemipmaps)
        : LLImageGL(usemipmaps),
-          mID(id)
+          mID(id),
+          mTargetHost(host)
 {
        init(true);
        sImageCount++;
 }
-LLViewerImage::LLViewerImage(const std::string& filename, const LLUUID& id, BOOL usemipmaps)
+LLViewerImage::LLViewerImage(const std::string& url, const LLUUID& id, BOOL usemipmaps)
        : LLImageGL(usemipmaps),
          mID(id),
-          mLocalFileName(filename)
+          mUrl(url)
 {
        init(true);
        sImageCount++;
@@ -265,7 +317,7 @@ void LLViewerImage::init(bool firstinit)
        }
        mIsMediaTexture = FALSE;
-        mBoostLevel = LLViewerImage::BOOST_NONE;
+        mBoostLevel =  LLViewerImageBoostLevel::BOOST_NONE;
        
        // Only set mIsMissingAsset true when we know for certain that the database
        // does not contain this image.
@@ -277,8 +329,6 @@ void LLViewerImage::init(bool firstinit)
        mRawDiscardLevel = INVALID_DISCARD_LEVEL;
        mMinDiscardLevel = 0;
-        mTargetHost = LLHost::invalid;
        mHasFetcher = FALSE;
        mIsFetching = FALSE;
        mFetchState = 0;
@@ -287,6 +337,15 @@ void LLViewerImage::init(bool firstinit)
        mFetchDeltaTime = 999999.f;
        mDecodeFrame = 0;
        mVisibleFrame = 0;
+        mForSculpt = FALSE ;
+        mCachedRawImage = NULL ;
+        mCachedRawDiscardLevel = -1 ;
+        mCachedRawImageReady = FALSE ;
+        mNeedsResetMaxVirtualSize = FALSE ;
+        mForceToSaveRawImage  = FALSE ;
+        mSavedRawDiscardLevel = -1 ;
+        mDesiredSavedRawDiscardLevel = -1 ;
 }
 // virtual
@@ -322,6 +381,7 @@ LLViewerImage::~LLViewerImage()
 void LLViewerImage::cleanup()
 {
+        mFaceList.clear() ;
        for(callback_list_t::iterator iter = mLoadedCallbackList.begin();
                iter != mLoadedCallbackList.end(); )
        {
@@ -336,7 +396,9 @@ void LLViewerImage::cleanup()
        
        // Clean up image data
        destroyRawImage();
-        
+        mCachedRawImage = NULL ;
+        mCachedRawDiscardLevel = -1 ;
+        mCachedRawImageReady = FALSE ;
        // LLImageGL::cleanup will get called more than once when this is used in the destructor.
        LLImageGL::cleanup();
 }
@@ -365,6 +427,63 @@ void LLViewerImage::destroyTexture()
        destroyGLTexture() ;
 }
+void LLViewerImage::addToCreateTexture()
+{
+        if(isForSculptOnly())
+        {
+                //just update some variables, not to create a real GL texture.
+                createGLTexture(mRawDiscardLevel, mRawImage, 0, FALSE) ;
+                mNeedsCreateTexture = FALSE ;
+                destroyRawImage();
+        }
+        else
+        {       
+#if 1
+                //
+                //if mRequestedDiscardLevel > mDesiredDiscardLevel, we assume the required image res keep going up,
+                //so do not scale down the over qualified image.
+                //Note: scaling down image is expensensive. Do it only when very necessary.
+                //
+                if(mRequestedDiscardLevel <= mDesiredDiscardLevel)
+                {
+                        S32 w = mFullWidth >> mRawDiscardLevel;
+                        S32 h = mFullHeight >> mRawDiscardLevel;
+                        //if big image, do not load extra data
+                        //scale it down to size >= LLViewerImage::sMinLargeImageSize
+                        if(w * h > LLViewerImage::sMinLargeImageSize)
+                        {
+                                S32 d_level = llmin(mRequestedDiscardLevel, (S32)mDesiredDiscardLevel) - mRawDiscardLevel ;
+                                
+                                if(d_level > 0)
+                                {
+                                        S32 i = 0 ;
+                                        while((d_level > 0) && ((w >> i) * (h >> i) > LLViewerImage::sMinLargeImageSize))
+                                        {
+                                                i++;
+                                                d_level--;
+                                        }
+                                        if(i > 0)
+                                        {
+                                                mRawDiscardLevel += i ;
+                                                if(mRawDiscardLevel >= getDiscardLevel() && getDiscardLevel() > 0)
+                                                {
+                                                        mNeedsCreateTexture = FALSE ;
+                                                        destroyRawImage();
+                                                        return ;
+                                                }
+                                                mRawImage->scale(w >> i, h >> i) ;                                      
+                                        }
+                                }
+                        }
+                }
+#endif
+                mNeedsCreateTexture = TRUE;
+                gImageList.mCreateTextureList.insert(this);
+        }       
+        return ;
+}
 // ONLY called from LLViewerImageList
 BOOL LLViewerImage::createTexture(S32 usename/*= 0*/)
 {
@@ -386,7 +505,7 @@ BOOL LLViewerImage::createTexture(S32 usename/*= 0*/)
        if (!gNoRender)
        {
                // store original size only for locally-sourced images
-                if (!mLocalFileName.empty())
+                if (mUrl.compare(0, 7, "file://") == 0)
                {
                        mOrigWidth = mRawImage->getWidth();
                        mOrigHeight = mRawImage->getHeight();
@@ -457,29 +576,54 @@ BOOL LLViewerImage::createTexture(S32 usename/*= 0*/)
 //============================================================================
-void LLViewerImage::addTextureStats(F32 virtual_size) const // = 1.0
+void LLViewerImage::addTextureStats(F32 virtual_size, BOOL needs_gltexture) const
 {
-        if (virtual_size > mMaxVirtualSize)
+        if(needs_gltexture)
        {
-                mMaxVirtualSize = virtual_size;
+                mNeedsGLTexture = TRUE ;
        }
-}
-void LLViewerImage::resetTextureStats(BOOL zero)
+        if(mNeedsResetMaxVirtualSize)
-{
-        if (zero)
        {
-                mMaxVirtualSize = 0.0f;
+                //flag to reset the values because the old values are used.
+                mNeedsResetMaxVirtualSize = FALSE ;
+                mMaxVirtualSize = virtual_size;         
+                mAdditionalDecodePriority = 0.f ;       
+                mNeedsGLTexture = needs_gltexture ;
        }
-        else
+        else if (virtual_size > mMaxVirtualSize)
        {
-                mMaxVirtualSize -= mMaxVirtualSize * .10f; // decay by 5%/update
+                mMaxVirtualSize = virtual_size;
-        }
+        }       
+}
+void LLViewerImage::resetTextureStats()
+{
+        mMaxVirtualSize = 0.0f;
+        mAdditionalDecodePriority = 0.f ;       
+        mNeedsResetMaxVirtualSize = FALSE ;
+}
+BOOL LLViewerImage::isUpdateFrozen()
+{
+        return LLViewerImage::sFreezeImageScalingDown && !getDiscardLevel() ;
+}
+BOOL LLViewerImage::isLargeImage()
+{
+        return mTexelsPerImage > LLViewerImage::sMinLargeImageSize ;
 }
 // This is gauranteed to get called periodically for every texture
 void LLViewerImage::processTextureStats()
-{
+{                       
+        //no need to update if the texture reaches its highest res and the memory is sufficient.
+        //if(isUpdateFrozen())
+        //{
+        //      return ;
+        //}
+        updateVirtualSize() ;
        // Generate the request priority and render priority
        if (mDontDiscard || !getUseMipMaps())
        {
@@ -487,7 +631,7 @@ void LLViewerImage::processTextureStats()
                if (mFullWidth > MAX_IMAGE_SIZE_DEFAULT || mFullHeight > MAX_IMAGE_SIZE_DEFAULT)
                        mDesiredDiscardLevel = 1; // MAX_IMAGE_SIZE_DEFAULT = 1024 and max size ever is 2048
        }
-        else if (mBoostLevel < LLViewerImage::BOOST_HIGH && mMaxVirtualSize <= 10.f)
+        else if (mBoostLevel < LLViewerImageBoostLevel::BOOST_HIGH && mMaxVirtualSize <= 10.f)
        {
                // If the image has not been significantly visible in a while, we don't want it
                mDesiredDiscardLevel = llmin(mMinDesiredDiscardLevel, (S8)(MAX_DISCARD_LEVEL + 1));
@@ -504,15 +648,14 @@ void LLViewerImage::processTextureStats()
                S32 fullwidth = llmin(mFullWidth,(S32)MAX_IMAGE_SIZE_DEFAULT);
                S32 fullheight = llmin(mFullHeight,(S32)MAX_IMAGE_SIZE_DEFAULT);
                mTexelsPerImage = (F32)fullwidth * fullheight;
                F32 discard_level = 0.f;
                // If we know the output width and height, we can force the discard
                // level to the correct value, and thus not decode more texture
                // data than we need to.
-                if (mBoostLevel == LLViewerImage::BOOST_UI ||
+                if (mBoostLevel == LLViewerImageBoostLevel::BOOST_UI ||
-                        mBoostLevel == LLViewerImage::BOOST_PREVIEW ||
+                        mBoostLevel == LLViewerImageBoostLevel::BOOST_PREVIEW ||
-                        mBoostLevel == LLViewerImage::BOOST_AVATAR_SELF)        // JAMESDEBUG what about AVATAR_BAKED_SELF?
+                        mBoostLevel == LLViewerImageBoostLevel::BOOST_AVATAR_SELF)      // JAMESDEBUG what about AVATAR_BAKED_SELF?
                {
                        discard_level = 0; // full res
                }
@@ -527,6 +670,12 @@ void LLViewerImage::processTextureStats()
                }
                else
                {
+                        if(isLargeImage() && !isJustBound() && mAdditionalDecodePriority < 1.0f)
+                        {
+                                //if is a big image and not being used recently, nor close to the view point, do not load hi-res data.
+                                mMaxVirtualSize = llmin(mMaxVirtualSize, (F32)LLViewerImage::sMinLargeImageSize) ;
+                        }
+                        
                        if ((mCalculatedDiscardLevel >= 0.f) &&
                                (llabs(mMaxVirtualSize - mDiscardVirtualSize) < mMaxVirtualSize*.20f))
                        {
@@ -541,15 +690,14 @@ void LLViewerImage::processTextureStats()
                                mCalculatedDiscardLevel = discard_level;
                        }
                }
-                if (mBoostLevel < LLViewerImage::BOOST_HIGH)
+                if (mBoostLevel < LLViewerImageBoostLevel::BOOST_HIGH)
                {
-                        static const F32 discard_bias = -.5f; // Must be < 1 or highest discard will never load!
-                        discard_level += discard_bias;
                        discard_level += sDesiredDiscardBias;
                        discard_level *= sDesiredDiscardScale; // scale
+                        discard_level += sCameraMovingDiscardBias ;
                }
                discard_level = floorf(discard_level);
-//              discard_level -= (gImageList.mVideoMemorySetting>>1); // more video ram = higher detail
                F32 min_discard = 0.f;
                if (mFullWidth > MAX_IMAGE_SIZE_DEFAULT || mFullHeight > MAX_IMAGE_SIZE_DEFAULT)
@@ -567,43 +715,76 @@ void LLViewerImage::processTextureStats()
                // if possible.  Now we check to see if we have it, and take the
                // proper action if we don't.
                //
-                BOOL increase_discard = FALSE;
                S32 current_discard = getDiscardLevel();
                if ((sDesiredDiscardBias > 0.0f) &&
                        (current_discard >= 0 && mDesiredDiscardLevel >= current_discard))
                {
-                        if ( BYTES_TO_MEGA_BYTES(sBoundTextureMemoryInBytes) > sMaxBoundTextureMemInMegaBytes * texmem_middle_bound_scale)
+                        // Limit the amount of GL memory bound each frame
+                        if ( (BYTES_TO_MEGA_BYTES(sBoundTextureMemoryInBytes) > sMaxBoundTextureMemInMegaBytes * texmem_middle_bound_scale) &&
+                                (!getBoundRecently() || mDesiredDiscardLevel >= mCachedRawDiscardLevel))
                        {
-                                // Limit the amount of GL memory bound each frame
+                                scaleDown() ;
-                                if (mDesiredDiscardLevel > current_discard)
-                                {
-                                        increase_discard = TRUE;
-                                }
                        }
-                        if ( BYTES_TO_MEGA_BYTES(sTotalTextureMemoryInBytes) > sMaxTotalTextureMemInMegaBytes*texmem_middle_bound_scale)
+                        // Only allow GL to have 2x the video card memory
+                        else if ( (BYTES_TO_MEGA_BYTES(sTotalTextureMemoryInBytes) > sMaxTotalTextureMemInMegaBytes*texmem_middle_bound_scale) &&
+                                (!getBoundRecently() || mDesiredDiscardLevel >= mCachedRawDiscardLevel))
                        {
-                                // Only allow GL to have 2x the video card memory
+                                scaleDown() ;
-                                if (!getBoundRecently())
-                                {
-                                        increase_discard = TRUE;
-                                }
                        }
-                        if (increase_discard)
+                }
+        }
+}
+void LLViewerImage::updateVirtualSize() 
+{       
+#if 1
+        if(mNeedsResetMaxVirtualSize)
+        {
+                addTextureStats(0.f, FALSE) ;//reset
+        }
+        if(mFaceList.size() > 0) 
+        {                               
+                for(std::list<LLFace*>::iterator iter = mFaceList.begin(); iter != mFaceList.end(); ++iter)
+                {
+                        LLFace* facep = *iter ;
+                        if(facep->getDrawable()->isRecentlyVisible())
                        {
-                                //                      llinfos << "DISCARDED: " << mID << " Discard: " << current_discard << llendl;
+                                addTextureStats(facep->getVirtualSize()) ;
-                                sBoundTextureMemoryInBytes -= mTextureMemory;
+                                setAdditionalDecodePriority(facep->getImportanceToCamera()) ;
-                                sTotalTextureMemoryInBytes -= mTextureMemory;
-                                // Increase the discard level (reduce the texture res)
-                                S32 new_discard = current_discard+1;
-                                setDiscardLevel(new_discard);
-                                sBoundTextureMemoryInBytes += mTextureMemory;
-                                sTotalTextureMemoryInBytes += mTextureMemory;
                        }
-                }
+                }       
        }
+        mNeedsResetMaxVirtualSize = TRUE ;
+#endif  
 }
+void LLViewerImage::scaleDown()
+{
+        if(getHasGLTexture() && mCachedRawDiscardLevel > getDiscardLevel())
+        {               
+                switchToCachedImage() ; 
+        }
+}
+//use the mCachedRawImage to (re)generate the gl texture.
+void LLViewerImage::switchToCachedImage()
+{
+        if(mCachedRawImage.notNull())
+        {
+                mRawImage = mCachedRawImage ;
+                if (getComponents() != mRawImage->getComponents())
+                {
+                        // We've changed the number of components, so we need to move any
+                        // objects using this pool to a different pool.
+                        mComponents = mRawImage->getComponents();
+                        gImageList.dirtyImage(this);
+                }                       
+                mIsRawImageValid = TRUE;
+                mRawDiscardLevel = mCachedRawDiscardLevel ;
+                gImageList.mCreateTextureList.insert(this);
+                mNeedsCreateTexture = TRUE;             
+        }
+}
 //============================================================================
 F32 LLViewerImage::calcDecodePriority()
@@ -619,9 +800,19 @@ F32 LLViewerImage::calcDecodePriority()
        {
                return mDecodePriority; // no change while waiting to create
        }
+        if(mForceToSaveRawImage)
+        {
+                return maxDecodePriority() ;
+        }
-        F32 priority;
        S32 cur_discard = getDiscardLevel();
+        
+        //no need to update if the texture reaches its highest res and the memory is sufficient.
+        //if(LLViewerImage::sFreezeImageScalingDown && !cur_discard)
+        //{
+        //      return -5.0f ;
+        //}
        bool have_all_data = (cur_discard >= 0 && (cur_discard <= mDesiredDiscardLevel));
        F32 pixel_priority = fsqrtf(mMaxVirtualSize);
        const S32 MIN_NOT_VISIBLE_FRAMES = 30; // NOTE: this function is not called every frame
@@ -631,23 +822,36 @@ F32 LLViewerImage::calcDecodePriority()
                mVisibleFrame = mDecodeFrame;
        }
        
+        F32 priority = 0.f;     
        if (mIsMissingAsset)
        {
                priority = 0.0f;
+        }       
+        else if(mDesiredDiscardLevel >= cur_discard && cur_discard > -1)
+        {
+                priority = -1.0f ;
+        }
+        else if (!isJustBound() && mCachedRawImageReady)
+        {
+                priority = -1.0f;
+        }
+        else if(mCachedRawDiscardLevel > -1 && mDesiredDiscardLevel >= mCachedRawDiscardLevel)
+        {
+                priority = -1.0f;
        }
        else if (mDesiredDiscardLevel > mMaxDiscardLevel)
        {
                // Don't decode anything we don't need
                priority = -1.0f;
        }
-        else if (mBoostLevel == LLViewerImage::BOOST_UI && !have_all_data)
+        else if (mBoostLevel == LLViewerImageBoostLevel::BOOST_UI && !have_all_data)
        {
                priority = 1.f;
        }
        else if (pixel_priority <= 0.f && !have_all_data)
        {
                // Not on screen but we might want some data
-                if (mBoostLevel > BOOST_HIGH)
+                if (mBoostLevel > LLViewerImageBoostLevel::BOOST_HIGH)
                {
                        // Always want high boosted images
                        priority = 1.f;
@@ -695,12 +899,16 @@ F32 LLViewerImage::calcDecodePriority()
                        ddiscard-=2;
                }
                ddiscard = llclamp(ddiscard, 0, 4);
                priority = ddiscard*100000.f;
        }
        if (priority > 0.0f)
        {
-                pixel_priority = llclamp(pixel_priority, 0.0f, priority-1.f); // priority range = 100000-900000
+                // priority range = 100000-900000
-                if ( mBoostLevel > BOOST_HIGH)
+                pixel_priority = llclamp(pixel_priority, 0.0f, priority-1.f); 
+                // priority range = [100000.f, 2000000.f]
+                if ( mBoostLevel > LLViewerImageBoostLevel::BOOST_HIGH)
                {
                        priority = 1000000.f + pixel_priority + 1000.f * mBoostLevel;
                }
@@ -708,7 +916,14 @@ F32 LLViewerImage::calcDecodePriority()
                {
                        priority +=      0.f + pixel_priority + 1000.f * mBoostLevel;
                }
+                
+                // priority range = [2100000.f, 5000000.f] if mAdditionalDecodePriority > 1.0
+                if(mAdditionalDecodePriority > 1.0f)
+                {
+                        priority += 2000000.f + mAdditionalDecodePriority ;
+                }
        }
        return priority;
 }
@@ -716,7 +931,7 @@ F32 LLViewerImage::calcDecodePriority()
 //static
 F32 LLViewerImage::maxDecodePriority()
 {
-        return 2000000.f;
+        return 6000000.f;
 }
 void LLViewerImage::setDecodePriority(F32 priority)
@@ -725,15 +940,30 @@ void LLViewerImage::setDecodePriority(F32 priority)
        mDecodePriority = priority;
 }
-void LLViewerImage::setBoostLevel(S32 level)
+F32 LLViewerImage::maxAdditionalDecodePriority()
+{
+        return 2000000.f;
+}
+void LLViewerImage::setAdditionalDecodePriority(F32 priority)
 {
+        priority *= maxAdditionalDecodePriority();
+        if(mAdditionalDecodePriority < priority)
+        {
+                mAdditionalDecodePriority = priority;
+        }
+}
+//------------------------------------------------------------
+void LLViewerImage::setBoostLevel(S32 level)
+{       
        mBoostLevel = level;
-        if (level >= LLViewerImage::BOOST_HIGH)
+        if(gAuditTexture)
        {
-                processTextureStats();
+                setCategory(mBoostLevel);
        }
-        if(mBoostLevel != LLViewerImage::BOOST_NONE)
+        if(mBoostLevel != LLViewerImageBoostLevel::BOOST_NONE)
        {
                setNoDelete() ;         
        }
@@ -785,11 +1015,20 @@ bool LLViewerImage::updateFetch()
        S32 desired_discard = getDesiredDiscardLevel();
        F32 decode_priority = getDecodePriority();
        decode_priority = llmax(decode_priority, 0.0f);
+        decode_priority = llmin(decode_priority, maxDecodePriority());
        
        if (mIsFetching)
        {
                // Sets mRawDiscardLevel, mRawImage, mAuxRawImage
                S32 fetch_discard = current_discard;
+                if(mForceToSaveRawImage)
+                {
+                        if(fetch_discard >= 0)
+                        {
+                                fetch_discard = llmax(fetch_discard, mSavedRawDiscardLevel) ;
+                        }
+                }
                if (mRawImage.notNull()) sRawCount--;
                if (mAuxRawImage.notNull()) sAuxCount--;
                bool finished = LLAppViewer::getTextureFetch()->getRequestFinished(getID(), fetch_discard, mRawImage, mAuxRawImage);
@@ -809,6 +1048,7 @@ bool LLViewerImage::updateFetch()
                if (mRawImage.notNull())
                {
                        mRawDiscardLevel = fetch_discard;
+                        
                        if ((mRawImage->getDataSize() > 0 && mRawDiscardLevel >= 0) &&
                                (current_discard < 0 || mRawDiscardLevel < current_discard))
                        {
@@ -819,11 +1059,25 @@ bool LLViewerImage::updateFetch()
                                        mComponents = mRawImage->getComponents();
                                        gImageList.dirtyImage(this);
                                }                       
-                                mIsRawImageValid = TRUE;
+                                
-                                gImageList.mCreateTextureList.insert(this);
-                                mNeedsCreateTexture = TRUE;
                                mFullWidth = mRawImage->getWidth() << mRawDiscardLevel;
                                mFullHeight = mRawImage->getHeight() << mRawDiscardLevel;
+                                if(mFullWidth > MAX_IMAGE_SIZE || mFullHeight > MAX_IMAGE_SIZE)
+                                { 
+                                        //discard all oversized textures.
+                                        destroyRawImage();
+                                        setIsMissingAsset();
+                                        mRawDiscardLevel = INVALID_DISCARD_LEVEL ;
+                                        mIsFetching = FALSE ;
+                                }
+                                else
+                                {
+                                        mIsRawImageValid = TRUE;                        
+                                        addToCreateTexture() ;
+                                }
+                                return TRUE ;
                        }
                        else
                        {
@@ -846,7 +1100,7 @@ bool LLViewerImage::updateFetch()
                                }
                                else
                                {
-                                        llwarns << mID << ": Setting min discard to " << current_discard << llendl;
+                                        //llwarns << mID << ": Setting min discard to " << current_discard << llendl;
                                        mMinDiscardLevel = current_discard;
                                        desired_discard = current_discard;
                                }
@@ -865,8 +1119,19 @@ bool LLViewerImage::updateFetch()
                }
        }
-        bool make_request = true;
+        if (!mDontDiscard)
-        
+        {
+                if (mBoostLevel == 0)
+                {
+                        desired_discard = llmax(desired_discard, current_discard-1);
+                }
+                else
+                {
+                        desired_discard = llmax(desired_discard, current_discard-2);
+                }
+        }
+        bool make_request = true;       
        if (decode_priority <= 0)
        {
                make_request = false;
@@ -879,6 +1144,10 @@ bool LLViewerImage::updateFetch()
        {
                make_request = false;
        }
+        else if (!isJustBound() && mCachedRawImageReady)
+        {
+                make_request = false;
+        }
        else
        {
                if (mIsFetching)
@@ -906,41 +1175,21 @@ bool LLViewerImage::updateFetch()
                        h = getHeight(0);
                        c = getComponents();
                }
-                if (!mDontDiscard)
+                
-                {
-                        if (mBoostLevel == 0)
-                        {
-                                desired_discard = llmax(desired_discard, current_discard-1);
-                        }
-                        else
-                        {
-                                desired_discard = llmax(desired_discard, current_discard-2);
-                        }
-                }
                // bypass texturefetch directly by pulling from LLTextureCache
                bool fetch_request_created = false;
-                if (mLocalFileName.empty())
+                fetch_request_created = LLAppViewer::getTextureFetch()->createRequest(mUrl, getID(),getTargetHost(), decode_priority,
-                {
+                                                                                                                                                          w, h, c, desired_discard, needsAux());
-                        fetch_request_created = LLAppViewer::getTextureFetch()->createRequest(getID(), getTargetHost(), decode_priority,
-                                                                                         w, h, c, desired_discard,
-                                                                                         needsAux());
-                }
-                else
-                {
-                        fetch_request_created = LLAppViewer::getTextureFetch()->createRequest(mLocalFileName, getID(),getTargetHost(), decode_priority,
-                                                                                         w, h, c, desired_discard,
-                                                                                         needsAux());
-                }
                if (fetch_request_created)
-                {
+                {                               
                        mHasFetcher = TRUE;
                        mIsFetching = TRUE;
                        mRequestedDiscardLevel = desired_discard;
                        mFetchState = LLAppViewer::getTextureFetch()->getFetchState(mID, mDownloadProgress, mRequestedDownloadPriority,
-                                                                                                           mFetchPriority, mFetchDeltaTime, mRequestDeltaTime);
+                                                                                                                                                mFetchPriority, mFetchDeltaTime, mRequestDeltaTime);
-                }
+                }       
                // if createRequest() failed, we're finishing up a request for this UUID,
                // wait for it to complete
@@ -962,9 +1211,81 @@ bool LLViewerImage::updateFetch()
        return mIsFetching ? true : false;
 }
+//
+//force to fetch a new raw image for this texture
+//this function is to replace readBackRaw().
+//
+BOOL LLViewerImage::forceFetch()
+{
+        if(!mForceToSaveRawImage)
+        {
+                return false ;
+        }
+        if (mIsMediaTexture)
+        {
+                mForceToSaveRawImage = false ;
+                llassert_always(!mHasFetcher);
+                return false; // skip
+        }
+        if (mIsMissingAsset)
+        {
+                mForceToSaveRawImage = false ;
+                llassert_always(!mHasFetcher);
+                return false; // skip
+        }
+        if (!mLoadedCallbackList.empty() && mRawImage.notNull())
+        {
+                return false; // process any raw image data in callbacks before replacing
+        }
+        if(mRawImage.notNull() && mRawDiscardLevel <= mDesiredSavedRawDiscardLevel)
+        {
+                return false ; // mRawImage is enough
+        }
+        if(mIsFetching)
+        {
+                return false ;
+        }
+        S32 desired_discard = mDesiredSavedRawDiscardLevel ;
+        S32 current_discard = getDiscardLevel();
+        
+        bool fetch_request_created = false;
+        S32 w=0, h=0, c=0;
+        if (current_discard >= 0)
+        {
+                w = getWidth(0);
+                h = getHeight(0);
+                c = getComponents();
+        }
+        fetch_request_created = LLAppViewer::getTextureFetch()->createRequest(mUrl, getID(),getTargetHost(), maxDecodePriority(),
+                                                                                                                                                  w, h, c, desired_discard, needsAux());
+        if (fetch_request_created)
+        {
+                mHasFetcher = TRUE;
+                mIsFetching = TRUE;
+                // Set the image's decode priority to maxDecodePriority() too, or updateFetch() will set
+                // the request priority to 0 and terminate the fetch before we even started (SNOW-203).
+                gImageList.bumpToMaxDecodePriority(this);
+                mRequestedDiscardLevel = desired_discard ;
+                mFetchState = LLAppViewer::getTextureFetch()->getFetchState(mID, mDownloadProgress, mRequestedDownloadPriority,
+                                                                                                                                        mFetchPriority, mFetchDeltaTime, mRequestDeltaTime);
+        }       
+        return mIsFetching ? true : false;
+}
 void LLViewerImage::setIsMissingAsset()
 {
-        llwarns << mLocalFileName << " " << mID << ": Marking image as missing" << llendl;
+        if (mUrl.empty())
+        {
+                llwarns << mID << ": Marking image as missing" << llendl;
+        }
+        else
+        {
+                llwarns << mUrl << ": Marking image as missing" << llendl;
+        }
        if (mHasFetcher)
        {
                LLAppViewer::getTextureFetch()->deleteRequest(getID(), true);
@@ -1252,7 +1573,7 @@ bool LLViewerImage::bindError(S32 stage) const
        return res;
 }
-bool LLViewerImage::bindDefaultImage(S32 stage) const
+bool LLViewerImage::bindDefaultImage(S32 stage)
 {
        if (stage < 0) return false;
@@ -1271,24 +1592,17 @@ bool LLViewerImage::bindDefaultImage(S32 stage) const
                llwarns << "LLViewerImage::bindError failed." << llendl;
        }
        stop_glerror();
+        //check if there is cached raw image and switch to it if possible
+        switchToCachedImage() ;
        return res;
 }
 //virtual
 void LLViewerImage::forceImmediateUpdate()
 {
-        //only immediately update a deleted texture which is now being re-used.
+        gImageList.bumpToMaxDecodePriority(this) ;
-        if(!isDeleted())
-        {
-                return ;
-        }
-        //if already called forceImmediateUpdate()
-        if(mInImageList && mDecodePriority == LLViewerImage::maxDecodePriority())
-        {
-                return ;
-        }
-        gImageList.forceImmediateUpdate(this) ;
        return ;
 }
@@ -1302,21 +1616,165 @@ LLImageRaw* LLViewerImage::readBackRawImage(S8 discard_level)
                llerrs << "called with existing mRawImage" << llendl;
                mRawImage = NULL;
        }
-        mRawImage = new LLImageRaw(getWidth(discard_level), getHeight(discard_level), mComponents);
-        sRawCount++;
-        mRawDiscardLevel = discard_level;
-        readBackRaw(mRawDiscardLevel, mRawImage, false);
-        mIsRawImageValid = TRUE;
        
+        if(mSavedRawDiscardLevel >= 0 && mSavedRawDiscardLevel <= discard_level)
+        {
+                mRawImage = new LLImageRaw(getWidth(discard_level), getHeight(discard_level), getComponents()) ;
+                mRawImage->copy(mSavedRawImage) ;
+                mRawDiscardLevel = discard_level ;
+        }
+        else
+        {
+                mRawImage = mCachedRawImage ;
+                mRawDiscardLevel = mCachedRawDiscardLevel;
+        }
+        sRawCount++;    
+        mIsRawImageValid = TRUE;
        return mRawImage;
 }
+void LLViewerImage::saveRawImage() 
+{
+        if(mRawImage.isNull() || mRawDiscardLevel > mDesiredSavedRawDiscardLevel)
+        {
+                forceFetch() ;
+        }
+        if(mRawImage.isNull() || mSavedRawDiscardLevel == mRawDiscardLevel)
+        {
+                return ;
+        }
+        mSavedRawDiscardLevel = mRawDiscardLevel ;
+        mSavedRawImage = new LLImageRaw(mRawImage->getData(), mRawImage->getWidth(), mRawImage->getHeight(), mRawImage->getComponents()) ;
+        if(mSavedRawDiscardLevel <= mDesiredSavedRawDiscardLevel)
+        {
+                mForceToSaveRawImage = FALSE ;
+        }
+}
+void LLViewerImage::forceToSaveRawImage(S32 desired_discard) 
+{ 
+        mForceToSaveRawImage = TRUE ;
+        mDesiredSavedRawDiscardLevel = desired_discard ;
+        
+        forceFetch() ;
+}
+void LLViewerImage::destroySavedRawImage()
+{
+        mSavedRawImage = NULL ;
+        mForceToSaveRawImage  = FALSE ;
+        mSavedRawDiscardLevel = -1 ;
+        mDesiredSavedRawDiscardLevel = -1 ;
+}
 void LLViewerImage::destroyRawImage()
 {
        if (mRawImage.notNull()) sRawCount--;
        if (mAuxRawImage.notNull()) sAuxCount--;
+        if(mForceToSaveRawImage)
+        {
+                saveRawImage() ;
+        }
+        
+        setCachedRawImage() ;
        mRawImage = NULL;
        mAuxRawImage = NULL;
        mIsRawImageValid = FALSE;
        mRawDiscardLevel = INVALID_DISCARD_LEVEL;
 }
+void LLViewerImage::setCachedRawImage()
+{       
+        if(mRawImage == mCachedRawImage)
+        {
+                return ;
+        }
+        if(!mIsRawImageValid)
+        {
+                return ;
+        }
+        if(mCachedRawImageReady)
+        {
+                return ;
+        }
+        if(mCachedRawDiscardLevel < 0 || mCachedRawDiscardLevel > mRawDiscardLevel)
+        {
+                S32 i = 0 ;
+                S32 w = mRawImage->getWidth() ;
+                S32 h = mRawImage->getHeight() ;
+                S32 max_size = MAX_CACHED_RAW_IMAGE_AREA ;
+                if(LLViewerImageBoostLevel::BOOST_TERRAIN == mBoostLevel)
+                {
+                        max_size = MAX_CACHED_RAW_TERRAIN_IMAGE_AREA ;
+                }               
+                if(mForSculpt)
+                {
+                        max_size = MAX_CACHED_RAW_SCULPT_IMAGE_AREA ;
+                }
+                while(((w >> i) * (h >> i)) > max_size)
+                {
+                        ++i ;
+                }
+                mCachedRawImageReady = (!mRawDiscardLevel || ((w * h) >= max_size)) ;
+                
+                if(i)
+                {
+                        if(!(w >> i) || !(h >> i))
+                        {
+                                --i ;
+                        }
+                        mRawImage->scale(w >> i, h >> i) ;
+                }
+                mCachedRawImage = mRawImage ;
+                mCachedRawDiscardLevel = mRawDiscardLevel + i ;                 
+        }
+}
+void LLViewerImage::checkCachedRawSculptImage()
+{
+        if(mCachedRawImageReady && mCachedRawDiscardLevel > 0)
+        {
+                if(mCachedRawImage->getWidth() * mCachedRawImage->getHeight() < MAX_CACHED_RAW_SCULPT_IMAGE_AREA)
+                {
+                        mCachedRawImageReady = FALSE ;
+                }
+                else if(isForSculptOnly())
+                {
+                        resetTextureStats() ; //do not update this image any more.
+                }
+        }
+}
+BOOL LLViewerImage::isForSculptOnly() const
+{
+        return mForSculpt && !mNeedsGLTexture ;
+}
+void LLViewerImage::setForSculpt()   
+{
+        mForSculpt = TRUE ;
+        if(isForSculptOnly() && !getBoundRecently())
+        {
+                destroyGLTexture() ; //sculpt image does not need gl texture.
+        }
+        checkCachedRawSculptImage() ;
+}
+void LLViewerImage::addFace(LLFace* facep) 
+{
+        mFaceList.push_back(facep) ;
+}
+void LLViewerImage::removeFace(LLFace* facep) 
+{
+        mFaceList.remove(facep) ;
+}
diff --git a/linden/indra/newview/llviewerimage.h b/linden/indra/newview/llviewerimage.h
index 980ff56..fdf8ff0 100644
--- a/linden/indra/newview/llviewerimage.h
+++ b/linden/indra/newview/llviewerimage.h
@@ -41,6 +41,7 @@
 #include <map>
 #include <list>
+class LLFace;
 #define MIN_VIDEO_RAM_IN_MEGA_BYTES    32
 #define MAX_VIDEO_RAM_IN_MEGA_BYTES    512 // 512MB max for performance reasons.
@@ -75,6 +76,43 @@ public:
 class LLTextureBar;
+//=====================================
+struct LLViewerImageBoostLevel
+{
+        enum
+        {
+                BOOST_NONE                      = 0,
+                BOOST_AVATAR_BAKED      = 1,
+                BOOST_AVATAR            = 2,
+                BOOST_CLOUDS            = 3,
+                BOOST_SCULPTED      = 4,
+                
+                BOOST_HIGH                      = 5,
+                BOOST_TERRAIN           , // has to be high priority for minimap / low detail
+                BOOST_SELECTED          ,
+                BOOST_HUD                       ,
+                BOOST_AVATAR_BAKED_SELF ,
+                BOOST_UI                        ,
+                BOOST_PREVIEW           ,
+                BOOST_MAP                       ,
+                BOOST_MAP_VISIBLE       ,
+                BOOST_AVATAR_SELF       ,// needed for baking avatar
+                BOOST_MAX_LEVEL,
+                //LLImageGLCategory
+                TEXLAYER_BUMP = BOOST_MAX_LEVEL,
+                AVATAR_SCRATCH_TEX,
+                FONT,
+                BUMP_IMAGE,
+                DYNAMIC_TEX,
+                TEXLAYER_CACHE,
+                MEDIA,
+                ATLAS,
+                OTHER,
+                MAX_GL_IMAGE_CATEGORY
+        };
+};
+//=====================================
 class LLViewerImage : public LLImageGL
 {
        LOG_CLASS(LLViewerImage);
@@ -175,15 +213,15 @@ protected:
        /*virtual*/ ~LLViewerImage();
        
 public:
-        LLViewerImage(const std::string& filename, const LLUUID& id, BOOL usemipmaps = TRUE);
+        LLViewerImage(const std::string& url, const LLUUID& id, BOOL usemipmaps = TRUE);
-        LLViewerImage(const LLUUID& id, BOOL usemipmaps = TRUE);
+        LLViewerImage(const LLUUID& id, const LLHost& host = LLHost::invalid, BOOL usemipmaps = TRUE);
        LLViewerImage(const U32 width, const U32 height, const U8 components, BOOL usemipmaps);
        LLViewerImage(const LLImageRaw* raw, BOOL usemipmaps);
        /*virtual*/ void dump();        // debug info to llinfos
        /*virtual*/ bool bindError(const S32 stage = 0) const;
-        /*virtual*/ bool bindDefaultImage(const S32 stage = 0) const;
+        /*virtual*/ bool bindDefaultImage(const S32 stage = 0) ;
        /*virtual*/ void forceImmediateUpdate() ;
        
        void reinit(BOOL usemipmaps = TRUE);
@@ -192,8 +230,13 @@ public:
        // New methods for determining image quality/priority
        // texel_area_ratio is ("scaled" texel area)/(original texel area), approximately.
-        void addTextureStats(F32 virtual_size) const;
+        void addTextureStats(F32 virtual_size, BOOL needs_gltexture = TRUE) const;
-        void resetTextureStats(BOOL zero = FALSE);
+        void resetTextureStats();
+        void setAdditionalDecodePriority(F32 priority) ;
+        F32  maxAdditionalDecodePriority() ;
+        BOOL isLargeImage() ;
+        BOOL isUpdateFrozen() ;
        // Process image stats to determine priority/quality requirements.
        void processTextureStats();
@@ -207,6 +250,7 @@ public:
         // ONLY call from LLViewerImageList
        BOOL createTexture(S32 usename = 0);
        void destroyTexture() ;
+        void addToCreateTexture();
        BOOL needsAux() const                                                   { return mNeedsAux; }
@@ -217,32 +261,12 @@ public:
        void setMinDiscardLevel(S32 discard)    { mMinDesiredDiscardLevel = llmin(mMinDesiredDiscardLevel,(S8)discard); }
        
        // Host we think might have this image, used for baked av textures.
-        void setTargetHost(LLHost host)                 { mTargetHost = host; }
        LLHost getTargetHost() const                    { return mTargetHost; }
-        enum
-        {
-                BOOST_NONE                      = 0,
-                BOOST_AVATAR_BAKED      = 1,
-                BOOST_AVATAR            = 2,
-                BOOST_CLOUDS            = 3,
-                BOOST_SCULPTED      = 4,
-                
-                BOOST_HIGH                      = 10,
-                BOOST_TERRAIN           = 11, // has to be high priority for minimap / low detail
-                BOOST_SELECTED          = 12,
-                BOOST_HUD                       = 13,
-                BOOST_AVATAR_BAKED_SELF = 14,
-                BOOST_UI                        = 15,
-                BOOST_PREVIEW           = 16,
-                BOOST_MAP                       = 17,
-                BOOST_MAP_LAYER         = 18,
-                BOOST_AVATAR_SELF       = 19, // needed for baking avatar
-                BOOST_MAX_LEVEL
-        };
        void setBoostLevel(S32 level);
        S32  getBoostLevel() { return mBoostLevel; }
        
+        void updateVirtualSize() ;
        F32 getDecodePriority() const { return mDecodePriority; };
        F32 calcDecodePriority();
        static F32 maxDecodePriority();
@@ -271,6 +295,24 @@ public:
        S32 getOriginalWidth() { return mOrigWidth; }
        S32 getOriginalHeight() { return mOrigHeight; }
+        BOOL isForSculptOnly() const ;
+        void setForSculpt();
+        
+        void        checkCachedRawSculptImage() ;
+        LLImageRaw* getRawImage()const { return mRawImage ;}
+        S32         getRawImageLevel() const {return mRawDiscardLevel;}
+        LLImageRaw* getCachedRawImage() const { return mCachedRawImage ;}
+        S32         getCachedRawImageLevel() const {return mCachedRawDiscardLevel;}
+        BOOL        isCachedRawImageReady() const {return mCachedRawImageReady ;}
+        BOOL        isRawImageValid()const { return mIsRawImageValid ; }
+        
+        void        forceToSaveRawImage(S32 desired_discard = 0) ;
+        void        destroySavedRawImage() ;
+        BOOL        isSameTexture(const LLViewerImage* tex) const ;
+        void        addFace(LLFace* facep) ;
+        void        removeFace(LLFace* facep) ;
 private:
        /*virtual*/ void cleanup(); // Cleanup the LLViewerImage (so we can reinitialize it)
@@ -279,14 +321,19 @@ private:
        // Used to be in LLImageGL
        LLImageRaw* readBackRawImage(S8 discard_level = 0);
        void destroyRawImage();
-        
+        void saveRawImage() ;
+        BOOL forceFetch() ;
+        void scaleDown() ;      
+        void switchToCachedImage();
+        void setCachedRawImage() ;
 public:
        S32 mFullWidth;
        S32 mFullHeight;
        S32 mOrigWidth;
        S32 mOrigHeight;
-        std::string mLocalFileName;
+        std::string mUrl;
        // Data used for calculating required image priority/quality level/decimation
        mutable F32 mMaxVirtualSize;    // The largest virtual size of the image, in pixels - how much data to we need?
@@ -318,6 +365,7 @@ private:
        S8  mDesiredDiscardLevel;                       // The discard level we'd LIKE to have - if we have it and there's space
        S8  mMinDesiredDiscardLevel;            // The minimum discard level we'd like to have
        S8  mNeedsCreateTexture;        
+        mutable S8  mNeedsGLTexture;
        S8  mNeedsAux;                                  // We need to decode the auxiliary channels
        S8  mDecodingAux;                               // Are we decoding high components
        S8  mIsRawImageValid;
@@ -332,6 +380,7 @@ private:
        S32     mKnownDrawHeight;
        F32 mDecodePriority;                    // The priority for decoding this image.
+        mutable F32 mAdditionalDecodePriority;  // priority add to mDecodePriority.
        S32 mBoostLevel;                                // enum describing priority level
        
        typedef std::list<LLLoadedCallbackEntry*> callback_list_t;
@@ -342,12 +391,30 @@ private:
        S32     mMinDiscardLevel;
        F32 mCalculatedDiscardLevel; // Last calculated discard level
        
+        //keep a copy of mRawImage for some special purposes
+        //when mForceToSaveRawImage is set.
+        BOOL mForceToSaveRawImage ;
+        LLPointer<LLImageRaw> mSavedRawImage;
+        S32 mSavedRawDiscardLevel;
+        S32 mDesiredSavedRawDiscardLevel;
        // Used ONLY for cloth meshes right now.  Make SURE you know what you're 
        // doing if you use it for anything else! - djs
        LLPointer<LLImageRaw> mAuxRawImage;
+        //a small version of the copy of the raw image (<= 64 * 64)
+        LLPointer<LLImageRaw> mCachedRawImage;
+        S32 mCachedRawDiscardLevel;
+        BOOL mCachedRawImageReady; //the rez of the mCachedRawImage reaches the upper limit.
+        
        LLHost mTargetHost;     // if LLHost::invalid, just request from agent's simulator
        
+        BOOL   mForSculpt ; //a flag if the texture is used for a sculpt data.
+        mutable BOOL    mNeedsResetMaxVirtualSize ;
+        typedef std::list<LLFace*> ll_face_list_t ;
+        ll_face_list_t mFaceList ; //reverse pointer pointing to the faces using this image as texture
 public:
        static const U32 sCurrentFileVersion;
        // Default textures
@@ -361,6 +428,7 @@ public:
        static S32 sRawCount;
        static S32 sAuxCount;
        static LLTimer sEvaluationTimer;
+        static S8  sCameraMovingDiscardBias;
        static F32 sDesiredDiscardBias;
        static F32 sDesiredDiscardScale;
        static S32 sBoundTextureMemoryInBytes;
@@ -369,6 +437,12 @@ public:
        static S32 sMaxTotalTextureMemInMegaBytes;
        static S32 sMaxDesiredTextureMemInBytes ;
        static BOOL sDontLoadVolumeTextures;
+        static S32 sMaxSculptRez ;
+        static S32 sMinLargeImageSize ;
+        static S32 sMaxSmallImageSize ;
+        static BOOL sFreezeImageScalingDown ;//do not scale down image res if set.
+        static S32 sLLViewerImageCount ;
 };
 #endif
diff --git a/linden/indra/newview/llviewerimagelist.cpp b/linden/indra/newview/llviewerimagelist.cpp
index bd834a0..2280937 100644
--- a/linden/indra/newview/llviewerimagelist.cpp
+++ b/linden/indra/newview/llviewerimagelist.cpp
@@ -42,6 +42,7 @@
 #include "llimagetga.h"
 #include "llimagejpeg.h"
 #include "llimagepng.h"
+#include "llimageworker.h"
 #include "llsdserialize.h"
 #include "llsys.h"
@@ -58,6 +59,7 @@
 #include "llviewerimage.h"
 #include "llviewermedia.h"
 #include "llviewerregion.h"
+#include "llviewerstats.h"
 #include "pipeline.h"
 #include "llappviewer.h"
@@ -70,11 +72,6 @@ void (*LLViewerImageList::sUUIDCallback)(void **, const LLUUID&) = NULL;
 U32 LLViewerImageList::sTextureBits = 0;
 U32 LLViewerImageList::sTexturePackets = 0;
-const S32 IMAGES_PER_REQUEST = 42;
-const S32 IMAGES_MIN_UPDATES = 4;  // Always update the highest N images each frame
-const S32 IMAGES_MAX_PACKET_UPDATES = 1; // Only send N packets of IMAGES_PER_REQUEST in a frame
-const F32 RESEND_IMAGE_REQUEST_TIME = 15.f; // seconds
 LLViewerImageList gImageList;
 S32 LLViewerImageList::sNumImages = 0;
@@ -182,6 +179,7 @@ static std::string get_texture_list_name()
 void LLViewerImageList::doPrefetchImages()
 {
+#if 1
    if (LLAppViewer::instance()->getPurgeCache())
        {
                // cache was purged, no point
@@ -209,7 +207,7 @@ void LLViewerImageList::doPrefetchImages()
                        image->addTextureStats((F32)pixel_area);
                }
        }
-        
+#endif
        
 }
@@ -237,6 +235,10 @@ void LLViewerImageList::shutdown()
                {
                        continue; // avoid UI, baked, and other special images
                }
+                if(!image->getBoundRecently())
+                {
+                        continue ;
+                }
                S32 desired = image->getDesiredDiscardLevel();
                if (desired >= 0 && desired < MAX_DISCARD_LEVEL)
                {
@@ -323,17 +325,29 @@ LLViewerImage* LLViewerImageList::getImageFromFile(const std::string& filename,
                                                                                                   LLGLenum primary_format, 
                                                                                                   const LLUUID& force_id)
 {
-        if (gNoRender)
+        std::string full_path = gDirUtilp->findSkinnedFilename("textures", filename);
+        if (full_path.empty())
        {
-                // Never mind that this ignores image_set_id;
+                llwarns << "Failed to find local image file: " << filename << llendl;
-                // getImage() will handle that later.
                return getImage(IMG_DEFAULT, TRUE, TRUE);
        }
-        std::string full_path = gDirUtilp->findSkinnedFilename("textures", filename);
+        std::string url = "file://" + full_path;
-        if (full_path.empty())
+        return getImageFromUrl(url, usemipmaps, level_immediate, internal_format, primary_format, force_id);
+}
+LLViewerImage* LLViewerImageList::getImageFromUrl(const std::string& url,
+                                                                                                   BOOL usemipmaps,
+                                                                                                   BOOL level_immediate,
+                                                                                                   LLGLint internal_format,
+                                                                                                   LLGLenum primary_format, 
+                                                                                                   const LLUUID& force_id)
+{
+        if (gNoRender)
        {
-                llwarns << "Failed to find local image file: " << filename << llendl;
+                // Never mind that this ignores image_set_id;
+                // getImage() will handle that later.
                return getImage(IMG_DEFAULT, TRUE, TRUE);
        }
@@ -345,14 +359,14 @@ LLViewerImage* LLViewerImageList::getImageFromFile(const std::string& filename,
        }
        else
        {
-                new_id.generate(full_path);
+                new_id.generate(url);
        }
        LLPointer<LLViewerImage> imagep = hasImage(new_id);
        
        if (imagep.isNull())
        {
-                imagep = new LLViewerImage(full_path, new_id, usemipmaps);
+                imagep = new LLViewerImage(url, new_id, usemipmaps);
                
                if (internal_format && primary_format)
                {
@@ -364,7 +378,7 @@ LLViewerImage* LLViewerImageList::getImageFromFile(const std::string& filename,
                if (level_immediate)
                {
                        imagep->dontDiscard();
-                        imagep->setBoostLevel(LLViewerImage::BOOST_UI);
+                        imagep->setBoostLevel(LLViewerImageBoostLevel::BOOST_UI);
                }
        }
@@ -394,9 +408,7 @@ LLViewerImage* LLViewerImageList::getImage(const LLUUID &image_id,
        
        if (imagep.isNull())
        {
-                imagep = new LLViewerImage(image_id, usemipmaps);
+                imagep = new LLViewerImage(image_id, request_from_host, usemipmaps);
-                // Might want to request from host other than where the agent is. JC
-                imagep->setTargetHost(request_from_host);
                
                if (internal_format && primary_format)
                {
@@ -408,7 +420,7 @@ LLViewerImage* LLViewerImageList::getImage(const LLUUID &image_id,
                if (level_immediate)
                {
                        imagep->dontDiscard();
-                        imagep->setBoostLevel(LLViewerImage::BOOST_UI);
+                        imagep->setBoostLevel(LLViewerImageBoostLevel::BOOST_UI);
                }
                else
                {
@@ -511,23 +523,29 @@ void LLViewerImageList::dirtyImage(LLViewerImage *image)
 void LLViewerImageList::updateImages(F32 max_time)
 {
        llpushcallstacks ;
+        LLAppViewer::getTextureFetch()->setTextureBandwidth(LLViewerStats::getInstance()->mTextureKBitStat.getMeanPerSec());
        sNumImagesStat.addValue(sNumImages);
        sNumRawImagesStat.addValue(LLImageRaw::sRawImageCount);
        sGLTexMemStat.addValue((F32)BYTES_TO_MEGA_BYTES(LLImageGL::sGlobalTextureMemoryInBytes));
        sGLBoundMemStat.addValue((F32)BYTES_TO_MEGA_BYTES(LLImageGL::sBoundTextureMemoryInBytes));
        sRawMemStat.addValue((F32)BYTES_TO_MEGA_BYTES(LLImageRaw::sGlobalRawMemory));
        sFormattedMemStat.addValue((F32)BYTES_TO_MEGA_BYTES(LLImageFormatted::sGlobalFormattedMemory));
-        
        llpushcallstacks ;
        updateImagesDecodePriorities();
        llpushcallstacks ;
+        F32 total_max_time = max_time;
        max_time -= updateImagesFetchTextures(max_time);
        llpushcallstacks ;
-        max_time = llmin(llmax(max_time, 0.001f*10.f*gFrameIntervalSeconds), 0.001f);
+        max_time = llmax(max_time, total_max_time*.25f); // at least 25% of max_time
        max_time -= updateImagesCreateTextures(max_time);
+        
        llpushcallstacks ;
-        max_time = llmin(llmax(max_time, 0.001f*10.f*gFrameIntervalSeconds), 0.001f);
+        
-        llpushcallstacks ;
        if (!mDirtyTextureList.empty())
        {
                LLFastTimer t(LLFastTimer::FTM_IMAGE_MARK_DIRTY);
@@ -541,7 +559,7 @@ void LLViewerImageList::updateImages(F32 max_time)
        {
                //trigger loaded callbacks on local textures immediately
                LLViewerImage* image = *iter++;
-                if (!image->mLocalFileName.empty())
+                if (!image->mUrl.empty())
                {
                        // Do stuff to handle callbacks, update priorities, etc.
                        didone = image->doLoadedCallbacks();
@@ -627,7 +645,7 @@ void LLViewerImageList::updateImagesDecodePriorities()
                                        imagep->setInactive() ;                                                                         
                                }
                        }
-                        
                        imagep->processTextureStats();
                        F32 old_priority = imagep->getDecodePriority();
                        F32 old_priority_test = llmax(old_priority, 0.0f);
@@ -701,7 +719,7 @@ F32 LLViewerImageList::updateImagesCreateTextures(F32 max_time)
        return create_timer.getElapsedTimeF32();
 }
-void LLViewerImageList::forceImmediateUpdate(LLViewerImage* imagep)
+void LLViewerImageList::bumpToMaxDecodePriority(LLViewerImage* imagep)
 {
        if(!imagep)
        {
@@ -709,6 +727,11 @@ void LLViewerImageList::forceImmediateUpdate(LLViewerImage* imagep)
        }
        if(imagep->mInImageList)
        {
+                if (imagep->getDecodePriority() == LLViewerImage::maxDecodePriority())
+                {
+                        // Already at maximum.
+                        return;
+                }
                removeImageFromList(imagep);
        }
@@ -731,74 +754,76 @@ F32 LLViewerImageList::updateImagesFetchTextures(F32 max_time)
        const size_t max_update_count = llmin((S32) (1024*10.f*gFrameIntervalSeconds)+1, 256);
        
        // 32 high priority entries
-        std::set<LLViewerImage*> entries;
+        typedef std::vector<LLViewerImage*> entries_list_t;
+        entries_list_t entries;
        size_t update_counter = llmin(max_priority_count, mImageList.size());
        image_priority_list_t::iterator iter1 = mImageList.begin();
        while(update_counter > 0)
        {
-                // added extra granularity and verbosity for crash logging during 1.19.1 RC. -Brad
+                entries.push_back(*iter1);
-                if(iter1 == mImageList.end())
-                {
-                        llerrs << "DEV-12002: update_counter not calculated correctly!" << llendl;
-                        return 0.f;
-                }
-                LLPointer<LLViewerImage> const & ptr = *iter1;
-                LLViewerImage * img = ptr.get();
-                // added extra granularity and verbosity for crash logging during 1.19.1 RC. -Brad
-                if(img == NULL)
-                {
-                        llwarns << "DEV-12002: image is NULL!" << llendl;
-                }
-                entries.insert(img);
                ++iter1;
                update_counter--;
        }
        
        // 256 cycled entries
        update_counter = llmin(max_update_count, mUUIDMap.size());
-        uuid_map_t::iterator iter2 = mUUIDMap.upper_bound(mLastFetchUUID);
+        if (update_counter > 0)
-        while(update_counter > 0)
        {
-                if (iter2 == mUUIDMap.end())
+                uuid_map_t::iterator iter2 = mUUIDMap.upper_bound(mLastFetchUUID);
+                uuid_map_t::iterator iter2p = iter2;
+                while(update_counter > 0)
                {
-                        iter2 = mUUIDMap.begin();
+                        if (iter2 == mUUIDMap.end())
+                        {
+                                iter2 = mUUIDMap.begin();
+                        }
+                        entries.push_back(iter2->second);
+                        iter2p = iter2++;
+                        update_counter--;
                }
-                mLastFetchUUID = iter2->first;
+                mLastFetchUUID = iter2p->first;
-                entries.insert(iter2->second);
-                ++iter2;
-                update_counter--;
        }
        
+        S32 fetch_count = 0;
        S32 min_count = max_priority_count + max_update_count/4;
-        for (std::set<LLViewerImage*>::iterator iter3 = entries.begin();
+        for (entries_list_t::iterator iter3 = entries.begin();
                 iter3 != entries.end(); )
        {
                LLPointer<LLViewerImage> imagep = *iter3++;
                
-                imagep->updateFetch();
+                bool fetching = imagep->updateFetch();
+                if (fetching)
+                {
+                        fetch_count++;
+                }
                if (min_count <= 0 && image_op_timer.getElapsedTimeF32() > max_time)
                {
                        break;
                }
                min_count--;
        }
+        if (fetch_count == 0)
+        {
+                gDebugTimers[0].pause();
+        }
+        else
+        {
+                gDebugTimers[0].unpause();
+        }
+        
+        
        return image_op_timer.getElapsedTimeF32();
 }
 void LLViewerImageList::updateImagesUpdateStats()
 {
-        if (mUpdateStats)
+        if (mUpdateStats && mForceResetTextureStats)
        {
                for (image_priority_list_t::iterator iter = mImageList.begin();
                         iter != mImageList.end(); )
                {
                        LLViewerImage* imagep = *iter++;
-                        imagep->resetTextureStats(mForceResetTextureStats);
+                        imagep->resetTextureStats();
                }
                mUpdateStats = FALSE;
                mForceResetTextureStats = FALSE;
@@ -1348,7 +1373,7 @@ void LLUIImageList::onUIImageLoaded( BOOL success, LLViewerImage *src_vi, LLImag
                // for images grabbed from local files, apply clipping rectangle to restore original dimensions
                // from power-of-2 gl image
-                if (success && imagep.notNull() && src_vi && !src_vi->mLocalFileName.empty())
+                if (success && imagep.notNull() && src_vi && (src_vi->mUrl.compare(0, 7, "file://")==0))
                {
                        F32 clip_x = (F32)src_vi->getOriginalWidth() / (F32)src_vi->getWidth(0);
                        F32 clip_y = (F32)src_vi->getOriginalHeight() / (F32)src_vi->getHeight(0);
diff --git a/linden/indra/newview/llviewerimagelist.h b/linden/indra/newview/llviewerimagelist.h
index 5fad0a2..561e8e5 100644
--- a/linden/indra/newview/llviewerimagelist.h
+++ b/linden/indra/newview/llviewerimagelist.h
@@ -97,7 +97,7 @@ public:
                                                                         LLHost request_from_host = LLHost()
                                                                         );
        
-        LLViewerImage * getImageFromFile(const std::string& filename,
+        LLViewerImage * getImageFromUrl(const std::string& url,
                                                                         BOOL usemipmap = TRUE,
                                                                         BOOL level_immediate = FALSE,          // Get the requested level immediately upon creation.
                                                                         LLGLint internal_format = 0,
@@ -105,6 +105,14 @@ public:
                                                                         const LLUUID& force_id = LLUUID::null
                                                                         );
+        LLViewerImage * getImageFromFile(const std::string& filename,
+                                                                         BOOL usemipmap = TRUE,
+                                                                         BOOL level_immediate = FALSE,          // Get the requested level immediately upon creation.
+                                                                         LLGLint internal_format = 0,
+                                                                         LLGLenum primary_format = 0,
+                                                                         const LLUUID& force_id = LLUUID::null
+                                                                         );
+        
        // Request image from a specific host, used for baked avatar textures.
        // Implemented in header in case someone changes default params above. JC
        LLViewerImage* getImageFromHost(const LLUUID& image_id, LLHost host)
@@ -121,7 +129,7 @@ public:
        
        // Using image stats, determine what images are necessary, and perform image updates.
        void updateImages(F32 max_time);
-        void forceImmediateUpdate(LLViewerImage* imagep) ;
+        void bumpToMaxDecodePriority(LLViewerImage* imagep) ;
        // Decode and create textures for all images currently in list.
        void decodeAllImages(F32 max_decode_time); 
diff --git a/linden/indra/newview/llviewermessage.cpp b/linden/indra/newview/llviewermessage.cpp
index 94ae3ab..8bdbc30 100644
--- a/linden/indra/newview/llviewermessage.cpp
+++ b/linden/indra/newview/llviewermessage.cpp
@@ -106,6 +106,7 @@
 #include "llstatenums.h"
 #include "llstatusbar.h"
 #include "llimview.h"
+#include "lltexturestats.h"
 #include "lltool.h"
 #include "lltoolbar.h"
 #include "lltoolmgr.h"
diff --git a/linden/indra/newview/llviewerobject.cpp b/linden/indra/newview/llviewerobject.cpp
index 51908a5..860052c 100644
--- a/linden/indra/newview/llviewerobject.cpp
+++ b/linden/indra/newview/llviewerobject.cpp
@@ -2900,7 +2900,7 @@ F32 LLViewerObject::getMidScale() const
 }
-void LLViewerObject::updateTextures(LLAgent &agent)
+void LLViewerObject::updateTextures()
 {
 }
@@ -2915,14 +2915,14 @@ void LLViewerObject::boostTexturePriority(BOOL boost_children /* = TRUE */)
        S32 tex_count = getNumTEs();
        for (i = 0; i < tex_count; i++)
        {
-                getTEImage(i)->setBoostLevel(LLViewerImage::BOOST_SELECTED);
+                getTEImage(i)->setBoostLevel(LLViewerImageBoostLevel::BOOST_SELECTED);
        }
        if (isSculpted())
        {
                LLSculptParams *sculpt_params = (LLSculptParams *)getParameterEntry(LLNetworkData::PARAMS_SCULPT);
                LLUUID sculpt_id = sculpt_params->getSculptTexture();
-                gImageList.getImage(sculpt_id)->setBoostLevel(LLViewerImage::BOOST_SELECTED);
+                gImageList.getImage(sculpt_id)->setBoostLevel(LLViewerImageBoostLevel::BOOST_SELECTED);
        }
        
        if (boost_children)
diff --git a/linden/indra/newview/llviewerobject.h b/linden/indra/newview/llviewerobject.h
index 633e0eb..88f967f 100644
--- a/linden/indra/newview/llviewerobject.h
+++ b/linden/indra/newview/llviewerobject.h
@@ -190,7 +190,7 @@ public:
        S32 getNumFaces() const { return mNumFaces; }
        // Graphical stuff for objects - maybe broken out into render class later?
-        virtual void updateTextures(LLAgent &agent);
+        virtual void updateTextures();
        virtual void boostTexturePriority(BOOL boost_children = TRUE);  // When you just want to boost priority of this object
        
        virtual LLDrawable* createDrawable(LLPipeline *pipeline);
diff --git a/linden/indra/newview/llviewerobjectlist.cpp b/linden/indra/newview/llviewerobjectlist.cpp
index 059925e..3ac8fc4 100644
--- a/linden/indra/newview/llviewerobjectlist.cpp
+++ b/linden/indra/newview/llviewerobjectlist.cpp
@@ -612,7 +612,7 @@ void LLViewerObjectList::updateApparentAngles(LLAgent &agent)
                        //  Update distance & gpw 
                        objectp->setPixelAreaAndAngle(agent); // Also sets the approx. pixel area
-                        objectp->updateTextures(agent); // Update the image levels of textures for this object.
+                        objectp->updateTextures();      // Update the image levels of textures for this object.
                }
        }
diff --git a/linden/indra/newview/llviewerparceloverlay.cpp b/linden/indra/newview/llviewerparceloverlay.cpp
index 866c2a9..5cea9c2 100644
--- a/linden/indra/newview/llviewerparceloverlay.cpp
+++ b/linden/indra/newview/llviewerparceloverlay.cpp
@@ -71,7 +71,7 @@ LLViewerParcelOverlay::LLViewerParcelOverlay(LLViewerRegion* region, F32 region_
        // Use mipmaps = FALSE, clamped, NEAREST filter, for sharp edges
        mTexture = new LLImageGL(FALSE);
        mImageRaw = new LLImageRaw(mParcelGridsPerEdge, mParcelGridsPerEdge, OVERLAY_IMG_COMPONENTS);
-        mTexture->createGLTexture(0, mImageRaw);
+        mTexture->createGLTexture(0, mImageRaw, 0, TRUE, LLViewerImageBoostLevel::OTHER);
        gGL.getTexUnit(0)->activate();
        gGL.getTexUnit(0)->bind(mTexture);
        mTexture->setAddressMode(LLTexUnit::TAM_CLAMP);
diff --git a/linden/indra/newview/llviewerregion.cpp b/linden/indra/newview/llviewerregion.cpp
index 19b646c..1d380d7 100644
--- a/linden/indra/newview/llviewerregion.cpp
+++ b/linden/indra/newview/llviewerregion.cpp
@@ -1408,9 +1408,9 @@ void LLViewerRegion::setSeedCapability(const std::string& url)
        capabilityNames.append("EstateChangeInfo");
        capabilityNames.append("EventQueueGet");
        capabilityNames.append("FetchInventory");
-        capabilityNames.append("WebFetchInventoryDescendents");
        capabilityNames.append("FetchLib");
        capabilityNames.append("FetchLibDescendents");
+        capabilityNames.append("GetTexture");
        capabilityNames.append("GroupProposalBallot");
        capabilityNames.append("HomeLocation");
        capabilityNames.append("MapLayer");
@@ -1429,6 +1429,7 @@ void LLViewerRegion::setSeedCapability(const std::string& url)
        capabilityNames.append("SendUserReportWithScreenshot");
        capabilityNames.append("ServerReleaseNotes");
        capabilityNames.append("StartGroupProposal");
+        capabilityNames.append("TextureStats");
        capabilityNames.append("UntrustedSimulatorMessage");
        capabilityNames.append("UpdateAgentInformation");
        capabilityNames.append("UpdateAgentLanguage");
@@ -1441,6 +1442,7 @@ void LLViewerRegion::setSeedCapability(const std::string& url)
        capabilityNames.append("UploadBakedTexture");
        capabilityNames.append("ViewerStartAuction");
        capabilityNames.append("ViewerStats");
+        capabilityNames.append("WebFetchInventoryDescendents");
        // Please add new capabilities alphabetically to reduce
        // merge conflicts.
diff --git a/linden/indra/newview/llviewerwindow.cpp b/linden/indra/newview/llviewerwindow.cpp
index ef4e728..3d884ad 100644
--- a/linden/indra/newview/llviewerwindow.cpp
+++ b/linden/indra/newview/llviewerwindow.cpp
@@ -115,6 +115,7 @@
 #include "llhudview.h"
 #include "llimagebmp.h"
 #include "llimagej2c.h"
+#include "llimageworker.h"
 #include "llinventoryview.h"
 #include "llkeyboard.h"
 #include "lllineeditor.h"
@@ -1310,6 +1311,7 @@ LLViewerWindow::LLViewerWindow(
        // Init the image list.  Must happen after GL is initialized and before the images that
        // LLViewerWindow needs are requested.
+        LLImageGL::initClass(LLViewerImageBoostLevel::MAX_GL_IMAGE_CATEGORY) ;
        gImageList.init();
        LLViewerImage::initClass();
        gBumpImageList.init();
diff --git a/linden/indra/newview/llvlcomposition.cpp b/linden/indra/newview/llvlcomposition.cpp
index a269225..9c383c7 100644
--- a/linden/indra/newview/llvlcomposition.cpp
+++ b/linden/indra/newview/llvlcomposition.cpp
@@ -234,7 +234,7 @@ BOOL LLVLComposition::generateComposition()
        {
                if (mDetailTextures[i]->getDiscardLevel() < 0)
                {
-                        mDetailTextures[i]->setBoostLevel(LLViewerImage::BOOST_TERRAIN); // in case we are at low detail
+                        mDetailTextures[i]->setBoostLevel(LLViewerImageBoostLevel::BOOST_TERRAIN); // in case we are at low detail
                        mDetailTextures[i]->addTextureStats(BASE_SIZE*BASE_SIZE);
                        return FALSE;
                }
@@ -251,7 +251,7 @@ BOOL LLVLComposition::generateComposition()
                                ddiscard++;
                                min_dim /= 2;
                        }
-                        mDetailTextures[i]->setBoostLevel(LLViewerImage::BOOST_TERRAIN); // in case we are at low detail
+                        mDetailTextures[i]->setBoostLevel(LLViewerImageBoostLevel::BOOST_TERRAIN); // in case we are at low detail
                        mDetailTextures[i]->setMinDiscardLevel(ddiscard);
                        return FALSE;
                }
@@ -292,10 +292,10 @@ BOOL LLVLComposition::generateTexture(const F32 x, const F32 y,
                                ddiscard++;
                                min_dim /= 2;
                        }
-                        if (!mDetailTextures[i]->readBackRaw(ddiscard, mRawImages[i], false))
+                        mRawImages[i] = mDetailTextures[i]->getCachedRawImage() ;
+                        if (!mRawImages[i])
                        {
-                                llwarns << "Unable to read raw data for terrain detail texture: " << mDetailTextures[i]->getID() << llendl;
+                                llwarns << "no cached raw data for terrain detail texture: " << mDetailTextures[i]->getID() << llendl;
-                                mRawImages[i] = NULL;
                                return FALSE;
                        }
                        if (mDetailTextures[i]->getWidth(ddiscard) != BASE_SIZE ||
@@ -460,7 +460,7 @@ BOOL LLVLComposition::generateTexture(const F32 x, const F32 y,
        for (S32 i = 0; i < 4; i++)
        {
                // Un-boost detatil textures (will get re-boosted if rendering in high detail)
-                mDetailTextures[i]->setBoostLevel(LLViewerImage::BOOST_NONE);
+                mDetailTextures[i]->setBoostLevel(LLViewerImageBoostLevel::BOOST_NONE);
                mDetailTextures[i]->setMinDiscardLevel(MAX_DISCARD_LEVEL + 1);
        }
        
diff --git a/linden/indra/newview/llvoavatar.cpp b/linden/indra/newview/llvoavatar.cpp
index ab5d83e..d2f4a58 100644
--- a/linden/indra/newview/llvoavatar.cpp
+++ b/linden/indra/newview/llvoavatar.cpp
@@ -1272,6 +1272,49 @@ void LLVOAvatar::resetImpostors()
 // static
 void LLVOAvatar::deleteCachedImages(bool clearAll)
 {
+if(gAuditTexture)
+        {
+                S32 total_tex_size = sScratchTexBytes ;
+                S32 tex_size = SCRATCH_TEX_WIDTH * SCRATCH_TEX_HEIGHT ;
+                if( LLVOAvatar::sScratchTexNames.checkData( GL_LUMINANCE ) )
+                {
+                        LLImageGL::decTextureCounterStatic(tex_size, 1, LLViewerImageBoostLevel::AVATAR_SCRATCH_TEX) ;
+                        total_tex_size -= tex_size ;
+                }
+                if( LLVOAvatar::sScratchTexNames.checkData( GL_ALPHA ) )
+                {
+                        LLImageGL::decTextureCounterStatic(tex_size, 1, LLViewerImageBoostLevel::AVATAR_SCRATCH_TEX) ;
+                        total_tex_size -= tex_size ;
+                }
+                if( LLVOAvatar::sScratchTexNames.checkData( GL_COLOR_INDEX ) )
+                {
+                        LLImageGL::decTextureCounterStatic(tex_size, 1, LLViewerImageBoostLevel::AVATAR_SCRATCH_TEX) ;
+                        total_tex_size -= tex_size ;
+                }
+                if( LLVOAvatar::sScratchTexNames.checkData( GL_LUMINANCE_ALPHA ) )
+                {
+                        LLImageGL::decTextureCounterStatic(tex_size, 2, LLViewerImageBoostLevel::AVATAR_SCRATCH_TEX) ;
+                        total_tex_size -= 2 * tex_size ;
+                }
+                if( LLVOAvatar::sScratchTexNames.checkData( GL_RGB ) )
+                {
+                        LLImageGL::decTextureCounterStatic(tex_size, 3, LLViewerImageBoostLevel::AVATAR_SCRATCH_TEX) ;
+                        total_tex_size -= 3 * tex_size ;
+                }
+                if( LLVOAvatar::sScratchTexNames.checkData( GL_RGBA ) )
+                {
+                        LLImageGL::decTextureCounterStatic(tex_size, 4, LLViewerImageBoostLevel::AVATAR_SCRATCH_TEX) ;
+                        total_tex_size -= 4 * tex_size ;
+                }
+                //others
+                while(total_tex_size > 0)
+                {
+                        LLImageGL::decTextureCounterStatic(tex_size, 4, LLViewerImageBoostLevel::AVATAR_SCRATCH_TEX) ;
+                        total_tex_size -= 4 * tex_size ;
+                }
+        }
        if (LLTexLayerSet::sHasCaches)
        {
                lldebugs << "Deleting layer set caches" << llendl;
@@ -4701,7 +4744,7 @@ U32 LLVOAvatar::renderFootShadows()
        LLGLDepthTest test(GL_TRUE, GL_FALSE);
        //render foot shadows
        LLGLEnable blend(GL_BLEND);
-        gGL.getTexUnit(0)->bind(mShadowImagep.get());
+        gGL.getTexUnit(0)->bind(mShadowImagep.get(), TRUE);
        glColor4fv(mShadow0Facep->getRenderColor().mV);
        mShadow0Facep->renderIndexed(foot_mask);
        glColor4fv(mShadow1Facep->getRenderColor().mV);
@@ -4749,7 +4792,7 @@ U32 LLVOAvatar::renderImpostor(LLColor4U color)
 //------------------------------------------------------------------------
 // LLVOAvatar::updateTextures()
 //------------------------------------------------------------------------
-void LLVOAvatar::updateTextures(LLAgent &agent)
+void LLVOAvatar::updateTextures()
 {
        BOOL render_avatar = TRUE;
@@ -4816,9 +4859,9 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
                if (imagep)
                {
                        // Debugging code - maybe non-self avatars are downloading textures?
-                        //llinfos << "avatar self " << mIsSelf << " tex " << i 
+                        //llinfos << "avatar self " << mIsSelf << " tex " << index 
                        //      << " decode " << imagep->getDecodePriority()
-                        //      << " boost " << boost_avatar 
+                        //      << " boost " << imagep->getBoostLevel() 
                        //      << " size " << imagep->getWidth() << "x" << imagep->getHeight()
                        //      << " discard " << imagep->getDiscardLevel()
                        //      << " desired " << imagep->getDesiredDiscardLevel()
@@ -4826,7 +4869,7 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
                        
                        const LLTextureEntry *te = getTE(index);
                        F32 texel_area_ratio = fabs(te->mScaleS * te->mScaleT);
-                        S32 boost_level = mIsSelf ? LLViewerImage::BOOST_AVATAR_BAKED_SELF : LLViewerImage::BOOST_AVATAR_BAKED;
+                        S32 boost_level = mIsSelf ? LLViewerImageBoostLevel::BOOST_AVATAR_BAKED_SELF : LLViewerImageBoostLevel::BOOST_AVATAR_BAKED;
                        
                        // Spam if this is a baked texture, not set to default image, without valid host info
                        if (isIndexBakedTexture((ETextureIndex)index)
@@ -4849,6 +4892,12 @@ void LLVOAvatar::updateTextures(LLAgent &agent)
                                if (texture_dict->mIsLocalTexture)
                                {
                                        addLocalTextureStats((ETextureIndex)index, imagep, texel_area_ratio, render_avatar, layer_baked[baked_index]);
+                                        // SNOW-8 : temporary snowglobe1.0 fix for baked textures
+                                        if (render_avatar && !gGLManager.mIsDisabled )
+                                        {
+                                                // bind the texture so that its boost level won't be slammed
+                                                gGL.getTexUnit(0)->bind(imagep);
+                                        }
                                }
                                else if (texture_dict->mIsBakedTexture)
                                {
@@ -4886,12 +4935,12 @@ void LLVOAvatar::addLocalTextureStats( ETextureIndex idx, LLViewerImage* imagep,
                        if( mIsSelf )
                        {
                                desired_pixels = llmin(mPixelArea, (F32)TEX_IMAGE_AREA_SELF );
-                                imagep->setBoostLevel(LLViewerImage::BOOST_AVATAR_SELF);
+                                imagep->setBoostLevel(LLViewerImageBoostLevel::BOOST_AVATAR_SELF);
                        }
                        else
                        {
                                desired_pixels = llmin(mPixelArea, (F32)TEX_IMAGE_AREA_OTHER );
-                                imagep->setBoostLevel(LLViewerImage::BOOST_AVATAR);
+                                imagep->setBoostLevel(LLViewerImageBoostLevel::BOOST_AVATAR);
                        }
                        imagep->addTextureStats( desired_pixels / texel_area_ratio );
                        if (imagep->getDiscardLevel() < 0)
@@ -7111,12 +7160,12 @@ BOOL LLVOAvatar::bindScratchTexture( LLGLenum format )
                        if( *last_bind_time != LLImageGL::sLastFrameTime )
                        {
                                *last_bind_time = LLImageGL::sLastFrameTime;
-                                LLImageGL::updateBoundTexMem(texture_bytes);
+                                LLImageGL::updateBoundTexMemStatic(texture_bytes, SCRATCH_TEX_WIDTH * SCRATCH_TEX_HEIGHT, LLViewerImageBoostLevel::AVATAR_SCRATCH_TEX) ;
                        }
                }
                else
                {
-                        LLImageGL::updateBoundTexMem(texture_bytes);
+                        LLImageGL::updateBoundTexMemStatic(texture_bytes, SCRATCH_TEX_WIDTH * SCRATCH_TEX_HEIGHT, LLViewerImageBoostLevel::AVATAR_SCRATCH_TEX) ;
                        LLVOAvatar::sScratchTexLastBindTime.addData( format, new F32(LLImageGL::sLastFrameTime) );
                }
@@ -7138,7 +7187,8 @@ LLGLuint LLVOAvatar::getScratchTexName( LLGLenum format, U32* texture_bytes )
        {
        case GL_LUMINANCE:                      components = 1; internal_format = GL_LUMINANCE8;                break;
        case GL_ALPHA:                          components = 1; internal_format = GL_ALPHA8;                    break;
-        case GL_COLOR_INDEX:            components = 1; internal_format = GL_COLOR_INDEX8_EXT;  break;
+//      Support for GL_EXT_paletted_texture is deprecated
+//      case GL_COLOR_INDEX:            components = 1; internal_format = GL_COLOR_INDEX8_EXT;  break;
        case GL_LUMINANCE_ALPHA:        components = 2; internal_format = GL_LUMINANCE8_ALPHA8; break;
        case GL_RGB:                            components = 3; internal_format = GL_RGB8;                              break;
        case GL_RGBA:                           components = 4; internal_format = GL_RGBA8;                             break;
@@ -7180,6 +7230,12 @@ LLGLuint LLVOAvatar::getScratchTexName( LLGLenum format, U32* texture_bytes )
                LLVOAvatar::sScratchTexBytes += *texture_bytes;
                LLImageGL::sGlobalTextureMemoryInBytes += *texture_bytes;
+                if(gAuditTexture)
+                {
+                        LLImageGL::incTextureCounterStatic(SCRATCH_TEX_WIDTH * SCRATCH_TEX_HEIGHT, components, LLViewerImageBoostLevel::AVATAR_SCRATCH_TEX) ;
+                }
                return name;
        }
 }
@@ -7495,7 +7551,8 @@ void LLVOAvatar::clearChat()
 S32 LLVOAvatar::getLocalDiscardLevel( ETextureIndex index )
 {
-        if (!isIndexLocalTexture(index)) return FALSE;
+        // If the texture is not local, we don't care and treat it as fully loaded
+        if (!isIndexLocalTexture(index)) return 0;
        LocalTextureData &local_tex_data = mLocalTextureData[index];
        if (index >= 0
diff --git a/linden/indra/newview/llvoavatar.h b/linden/indra/newview/llvoavatar.h
index f759e15..33cec69 100644
--- a/linden/indra/newview/llvoavatar.h
+++ b/linden/indra/newview/llvoavatar.h
@@ -133,7 +133,7 @@ public:
                                                                                  LLVector3* bi_normal = NULL             // return the surface bi-normal at the intersection point
                );
-        /*virtual*/ void updateTextures(LLAgent &agent);
+        /*virtual*/ void updateTextures();
        // If setting a baked texture, need to request it from a non-local sim.
        /*virtual*/ S32 setTETexture(const U8 te, const LLUUID& uuid);
        /*virtual*/ void onShift(const LLVector3& shift_vector);
diff --git a/linden/indra/newview/llvoclouds.cpp b/linden/indra/newview/llvoclouds.cpp
index 9095ee4..a489f91 100644
--- a/linden/indra/newview/llvoclouds.cpp
+++ b/linden/indra/newview/llvoclouds.cpp
@@ -62,7 +62,7 @@ LLVOClouds::LLVOClouds(const LLUUID &id, const LLPCode pcode, LLViewerRegion *re
        mbCanSelect = FALSE;
        setNumTEs(1);
        LLViewerImage* image = gImageList.getImage(gCloudTextureID);
-        image->setBoostLevel(LLViewerImage::BOOST_CLOUDS);
+        image->setBoostLevel(LLViewerImageBoostLevel::BOOST_CLOUDS);
        setTEImage(0, image);
 }
@@ -101,7 +101,7 @@ void LLVOClouds::setPixelAreaAndAngle(LLAgent &agent)
        mPixelArea = 1500*100;
 }
-void LLVOClouds::updateTextures(LLAgent &agent)
+void LLVOClouds::updateTextures()
 {
        getTEImage(0)->addTextureStats(mPixelArea);
 }
diff --git a/linden/indra/newview/llvoclouds.h b/linden/indra/newview/llvoclouds.h
index f70ea5b..52e5a68 100644
--- a/linden/indra/newview/llvoclouds.h
+++ b/linden/indra/newview/llvoclouds.h
@@ -65,7 +65,7 @@ public:
        /*virtual*/ BOOL    isActive() const; // Whether this object needs to do an idleUpdate.
        F32 getPartSize(S32 idx);
-        /*virtual*/ void updateTextures(LLAgent &agent);
+        /*virtual*/ void updateTextures();
        /*virtual*/ void setPixelAreaAndAngle(LLAgent &agent); // generate accurate apparent angle and area
        
        void updateFaceSize(S32 idx) { }
diff --git a/linden/indra/newview/llvograss.cpp b/linden/indra/newview/llvograss.cpp
index dd4dabb..d0a36b0 100644
--- a/linden/indra/newview/llvograss.cpp
+++ b/linden/indra/newview/llvograss.cpp
@@ -339,7 +339,7 @@ void LLVOGrass::setPixelAreaAndAngle(LLAgent &agent)
 // BUG could speed this up by caching the relative_position and range calculations
-void LLVOGrass::updateTextures(LLAgent &agent)
+void LLVOGrass::updateTextures()
 {
        if (getTEImage(0))
        {
diff --git a/linden/indra/newview/llvograss.h b/linden/indra/newview/llvograss.h
index b759488..abfc7e1 100644
--- a/linden/indra/newview/llvograss.h
+++ b/linden/indra/newview/llvograss.h
@@ -72,7 +72,7 @@ public:
                                                                LLStrider<U16>& indicesp);
        void updateFaceSize(S32 idx) { }
-        /*virtual*/ void updateTextures(LLAgent &agent);                                                                                        
+        /*virtual*/ void updateTextures();                                                                                      
        /*virtual*/ BOOL updateLOD();
        /*virtual*/ void setPixelAreaAndAngle(LLAgent &agent); // generate accurate apparent angle and area
diff --git a/linden/indra/newview/llvoground.cpp b/linden/indra/newview/llvoground.cpp
index fe19e18..0ef0196 100644
--- a/linden/indra/newview/llvoground.cpp
+++ b/linden/indra/newview/llvoground.cpp
@@ -71,7 +71,7 @@ BOOL LLVOGround::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
 }
-void LLVOGround::updateTextures(LLAgent &agent)
+void LLVOGround::updateTextures()
 {
 }
diff --git a/linden/indra/newview/llvoground.h b/linden/indra/newview/llvoground.h
index f485bd0..b58ebae 100644
--- a/linden/indra/newview/llvoground.h
+++ b/linden/indra/newview/llvoground.h
@@ -51,7 +51,7 @@ public:
        
        // Graphical stuff for objects - maybe broken out into render class
        // later?
-        /*virtual*/ void updateTextures(LLAgent &agent);
+        /*virtual*/ void updateTextures();
        /*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline);
        /*virtual*/ BOOL                updateGeometry(LLDrawable *drawable);
diff --git a/linden/indra/newview/llvopartgroup.cpp b/linden/indra/newview/llvopartgroup.cpp
index 29036f4..a0f8068 100644
--- a/linden/indra/newview/llvopartgroup.cpp
+++ b/linden/indra/newview/llvopartgroup.cpp
@@ -108,7 +108,7 @@ void LLVOPartGroup::setPixelAreaAndAngle(LLAgent &agent)
        }
 }
-void LLVOPartGroup::updateTextures(LLAgent &agent)
+void LLVOPartGroup::updateTextures()
 {
        // Texture stats for particles need to be updated in a different way...
 }
diff --git a/linden/indra/newview/llvopartgroup.h b/linden/indra/newview/llvopartgroup.h
index 3dc3292..18583b4 100644
--- a/linden/indra/newview/llvopartgroup.h
+++ b/linden/indra/newview/llvopartgroup.h
@@ -61,7 +61,7 @@ public:
        virtual U32 getPartitionType() const;
        
        /*virtual*/ void setPixelAreaAndAngle(LLAgent &agent);
-        /*virtual*/ void updateTextures(LLAgent &agent);
+        /*virtual*/ void updateTextures();
        /*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline);
        /*virtual*/ BOOL        updateGeometry(LLDrawable *drawable);
diff --git a/linden/indra/newview/llvosky.cpp b/linden/indra/newview/llvosky.cpp
index d4df141..1b9c7c0 100644
--- a/linden/indra/newview/llvosky.cpp
+++ b/linden/indra/newview/llvosky.cpp
@@ -289,7 +289,7 @@ void LLSkyTex::create(const F32 brightness)
 void LLSkyTex::createGLImage(S32 which)
 {       
-        mImageGL[which]->createGLTexture(0, mImageRaw[which]);
+        mImageGL[which]->createGLTexture(0, mImageRaw[which], 0, TRUE, LLViewerImageBoostLevel::OTHER);
        mImageGL[which]->setAddressMode(LLTexUnit::TAM_CLAMP);
 }
@@ -1180,7 +1180,7 @@ BOOL LLVOSky::updateSky()
        return TRUE;
 }
-void LLVOSky::updateTextures(LLAgent &agent)
+void LLVOSky::updateTextures()
 {
        if (mSunTexturep)
        {
diff --git a/linden/indra/newview/llvosky.h b/linden/indra/newview/llvosky.h
index 3cf454d..333e144 100644
--- a/linden/indra/newview/llvosky.h
+++ b/linden/indra/newview/llvosky.h
@@ -492,7 +492,7 @@ public:
        
        // Graphical stuff for objects - maybe broken out into render class
        // later?
-        /*virtual*/ void updateTextures(LLAgent &agent);
+        /*virtual*/ void updateTextures();
        /*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline);
        /*virtual*/ BOOL                updateGeometry(LLDrawable *drawable);
diff --git a/linden/indra/newview/llvosurfacepatch.cpp b/linden/indra/newview/llvosurfacepatch.cpp
index 4980b50..d86f758 100644
--- a/linden/indra/newview/llvosurfacepatch.cpp
+++ b/linden/indra/newview/llvosurfacepatch.cpp
@@ -134,7 +134,7 @@ void LLVOSurfacePatch::setPixelAreaAndAngle(LLAgent &agent)
 }
-void LLVOSurfacePatch::updateTextures(LLAgent &agent)
+void LLVOSurfacePatch::updateTextures()
 {
 }
diff --git a/linden/indra/newview/llvosurfacepatch.h b/linden/indra/newview/llvosurfacepatch.h
index 2dd8651..d3b1447 100644
--- a/linden/indra/newview/llvosurfacepatch.h
+++ b/linden/indra/newview/llvosurfacepatch.h
@@ -74,7 +74,7 @@ public:
                                                                LLStrider<LLVector2> &texCoords1p,
                                                                LLStrider<U16> &indicesp);
-        /*virtual*/ void updateTextures(LLAgent &agent);
+        /*virtual*/ void updateTextures();
        /*virtual*/ void setPixelAreaAndAngle(LLAgent &agent); // generate accurate apparent angle and area
        /*virtual*/ void updateSpatialExtents(LLVector3& newMin, LLVector3& newMax);
diff --git a/linden/indra/newview/llvotextbubble.cpp b/linden/indra/newview/llvotextbubble.cpp
index de69aac..5943f9b 100644
--- a/linden/indra/newview/llvotextbubble.cpp
+++ b/linden/indra/newview/llvotextbubble.cpp
@@ -116,7 +116,7 @@ BOOL LLVOTextBubble::idleUpdate(LLAgent &agent, LLWorld	&world, const F64 &time)
 }
-void LLVOTextBubble::updateTextures(LLAgent &agent)
+void LLVOTextBubble::updateTextures()
 {
        // Update the image levels of all textures...
diff --git a/linden/indra/newview/llvotextbubble.h b/linden/indra/newview/llvotextbubble.h
index 45d4df2..7f84dbf 100644
--- a/linden/indra/newview/llvotextbubble.h
+++ b/linden/indra/newview/llvotextbubble.h
@@ -44,7 +44,7 @@ public:
        /*virtual*/ BOOL    isActive() const; // Whether this object needs to do an idleUpdate.
        /*virtual*/ BOOL idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time);
-        /*virtual*/ void updateTextures(LLAgent &agent);
+        /*virtual*/ void updateTextures();
        /*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline);
        /*virtual*/ BOOL                updateGeometry(LLDrawable *drawable);
        /*virtual*/ BOOL                updateLOD();
diff --git a/linden/indra/newview/llvotree.cpp b/linden/indra/newview/llvotree.cpp
index 3523d87..237f581 100644
--- a/linden/indra/newview/llvotree.cpp
+++ b/linden/indra/newview/llvotree.cpp
@@ -475,7 +475,7 @@ void LLVOTree::setPixelAreaAndAngle(LLAgent &agent)
 #endif
 }
-void LLVOTree::updateTextures(LLAgent &agent)
+void LLVOTree::updateTextures()
 {
        if (mTreeImagep)
        {
diff --git a/linden/indra/newview/llvotree.h b/linden/indra/newview/llvotree.h
index 748fc14..df0b5a9 100644
--- a/linden/indra/newview/llvotree.h
+++ b/linden/indra/newview/llvotree.h
@@ -69,7 +69,7 @@ public:
        // Graphical stuff for objects - maybe broken out into render class later?
        /*virtual*/ void render(LLAgent &agent);
        /*virtual*/ void setPixelAreaAndAngle(LLAgent &agent);
-        /*virtual*/ void updateTextures(LLAgent &agent);
+        /*virtual*/ void updateTextures();
        /*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline);
        /*virtual*/ BOOL                updateGeometry(LLDrawable *drawable);
diff --git a/linden/indra/newview/llvotreenew.h b/linden/indra/newview/llvotreenew.h
index 02f6d3a..4960d90 100644
--- a/linden/indra/newview/llvotreenew.h
+++ b/linden/indra/newview/llvotreenew.h
@@ -156,7 +156,7 @@ public:
        /*virtual*/ BOOL idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time);
        /*virtual*/ void render(LLAgent &agent);
-        /*virtual*/ void updateTextures(LLAgent &agent);
+        /*virtual*/ void updateTextures();
        /*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline);
        /*virtual*/ BOOL                updateGeometry(LLDrawable *drawable);
diff --git a/linden/indra/newview/llvovolume.cpp b/linden/indra/newview/llvovolume.cpp
index 607bb42..5f7327d 100644
--- a/linden/indra/newview/llvovolume.cpp
+++ b/linden/indra/newview/llvovolume.cpp
@@ -52,12 +52,10 @@
 #include "lldrawpoolbump.h"
 #include "llface.h"
 #include "llspatialpartition.h"
-// TEMP HACK ventrella
 #include "llhudmanager.h"
 #include "llflexibleobject.h"
 #include "llsky.h"
+#include "lltexturefetch.h"
 #include "llviewercamera.h"
 #include "llviewerimagelist.h"
 #include "llviewerregion.h"
@@ -69,7 +67,6 @@
 const S32 MIN_QUIET_FRAMES_COALESCE = 30;
 const F32 FORCE_SIMPLE_RENDER_AREA = 512.f;
 const F32 FORCE_CULL_AREA = 8.f;
-const S32 MAX_SCULPT_REZ = 128;
 BOOL gAnimateTextures = TRUE;
 extern BOOL gHideSelectedObjects;
@@ -406,28 +403,30 @@ BOOL LLVOVolume::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
        return TRUE;
 }
-void LLVOVolume::updateTextures(LLAgent &agent)
+void LLVOVolume::updateTextures()
 {
        const F32 TEXTURE_AREA_REFRESH_TIME = 5.f; // seconds
-        if (mDrawable.notNull() && mTextureUpdateTimer.getElapsedTimeF32() > TEXTURE_AREA_REFRESH_TIME)
+        if (mTextureUpdateTimer.getElapsedTimeF32() > TEXTURE_AREA_REFRESH_TIME)
        {
-                if (mDrawable->isVisible())
+                updateTextureVirtualSize();             
-                {
-                        updateTextures();
-                }
        }
 }
-void LLVOVolume::updateTextures()
+void LLVOVolume::updateTextureVirtualSize()
 {
        // Update the pixel area of all faces
+        if(mDrawable.isNull() || !mDrawable->isVisible())
+        {
+                return ;
+        }
        if (!gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SIMPLE))
        {
                return;
        }
        
-        if (LLViewerImage::sDontLoadVolumeTextures || mDrawable.isNull()) // || !mDrawable->isVisible())
+        if (LLViewerImage::sDontLoadVolumeTextures || LLAppViewer::getTextureFetch()->mDebugPause)
        {
                return;
        }
@@ -444,53 +443,51 @@ void LLVOVolume::updateTextures()
                LLFace* face = mDrawable->getFace(i);
                const LLTextureEntry *te = face->getTextureEntry();
                LLViewerImage *imagep = face->getTexture();
-                if (!imagep || !te ||
+                if (!imagep || !te ||                   
                        face->mExtents[0] == face->mExtents[1])
                {
                        continue;
                }
                
                F32 vsize;
-                
+                F32 old_size = face->getVirtualSize();
                if (isHUDAttachment())
                {
                        F32 area = (F32) LLViewerCamera::getInstance()->getScreenPixelArea();
                        vsize = area;
-                        imagep->setBoostLevel(LLViewerImage::BOOST_HUD);
+                        imagep->setBoostLevel(LLViewerImageBoostLevel::BOOST_HUD);
                        face->setPixelArea(area); // treat as full screen
                }
                else
                {
-                        vsize = getTextureVirtualSize(face);
+                        vsize = face->getTextureVirtualSize();
                }
-                mPixelArea = llmax(mPixelArea, face->getPixelArea());
+                mPixelArea = llmax(mPixelArea, face->getPixelArea());           
-                F32 old_size = face->getVirtualSize();
                if (face->mTextureMatrix != NULL)
                {
-                        if (vsize < MIN_TEX_ANIM_SIZE && old_size > MIN_TEX_ANIM_SIZE ||
+                        if ((vsize < MIN_TEX_ANIM_SIZE && old_size > MIN_TEX_ANIM_SIZE) ||
-                                vsize > MIN_TEX_ANIM_SIZE && old_size < MIN_TEX_ANIM_SIZE)
+                                (vsize > MIN_TEX_ANIM_SIZE && old_size < MIN_TEX_ANIM_SIZE))
                        {
                                gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_TCOORD, FALSE);
                        }
                }
                
                face->setVirtualSize(vsize);
-                imagep->addTextureStats(vsize);
                if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_AREA))
                {
                        if (vsize < min_vsize) min_vsize = vsize;
                        if (vsize > max_vsize) max_vsize = vsize;
                }
-                else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
+//              else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
-                {
+//              {
-                        F32 pri = imagep->getDecodePriority();
+//                      F32 pri = imagep->getDecodePriority();
-                        pri = llmax(pri, 0.0f);
+//                      pri = llmax(pri, 0.0f);
-                        if (pri < min_vsize) min_vsize = pri;
+//                      if (pri < min_vsize) min_vsize = pri;
-                        if (pri > max_vsize) max_vsize = pri;
+//                      if (pri > max_vsize) max_vsize = pri;
-                }
+//              }
                else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_FACE_AREA))
                {
                        F32 pri = mPixelArea;
@@ -506,31 +503,44 @@ void LLVOVolume::updateTextures()
                mSculptTexture = gImageList.getImage(id);
                if (mSculptTexture.notNull())
                {
-                        S32 lod = llmin(mLOD, 3);
-                        F32 lodf = ((F32)(lod + 1.0f)/4.f); 
-                        F32 tex_size = lodf * MAX_SCULPT_REZ;
-                        mSculptTexture->addTextureStats(2.f * tex_size * tex_size);
                        mSculptTexture->setBoostLevel(llmax((S32)mSculptTexture->getBoostLevel(),
-                                                                                                (S32)LLViewerImage::BOOST_SCULPTED));
+                                                                                                (S32)LLViewerImageBoostLevel::BOOST_SCULPTED));
-                }
+                        mSculptTexture->setForSculpt() ;
+                        
-                S32 texture_discard = mSculptTexture->getDiscardLevel(); //try to match the texture
+                        if(!mSculptTexture->isCachedRawImageReady())
-                S32 current_discard = mSculptLevel;
+                        {
+                                S32 lod = llmin(mLOD, 3);
+                                F32 lodf = ((F32)(lod + 1.0f)/4.f);
+                                F32 tex_size = lodf * LLViewerImage::sMaxSculptRez ;
+                                mSculptTexture->addTextureStats(2.f * tex_size * tex_size, FALSE);
+                        
+                                //if the sculpty very close to the view point, load first
+                                {                               
+                                        LLVector3 lookAt = getPositionAgent() - LLViewerCamera::getInstance()->getOrigin();
+                                        F32 dist = lookAt.normVec() ;
+                                        F32 cos_angle_to_view_dir = lookAt * LLViewerCamera::getInstance()->getXAxis() ;                                
+                                        mSculptTexture->setAdditionalDecodePriority(0.8f * LLFace::calcImportanceToCamera(cos_angle_to_view_dir, dist)) ;
+                                }
+                        }
+        
+                        S32 texture_discard = mSculptTexture->getCachedRawImageLevel(); //try to match the texture
+                        S32 current_discard = mSculptLevel;
-                if (texture_discard >= 0 && //texture has some data available
+                        if (texture_discard >= 0 && //texture has some data available
-                        (texture_discard < current_discard || //texture has more data than last rebuild
+                                (texture_discard < current_discard || //texture has more data than last rebuild
-                        current_discard < 0)) //no previous rebuild
+                                current_discard < 0)) //no previous rebuild
-                {
+                        {
-                        gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, FALSE);
+                                gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, FALSE);
-                        mSculptChanged = TRUE;
+                                mSculptChanged = TRUE;
-                }
+                        }
-                if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SCULPTED))
+                        if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SCULPTED))
                        {
                                setDebugText(llformat("T%d C%d V%d\n%dx%d",
-                                                                          texture_discard, current_discard, getVolume()->getSculptLevel(),
+                                                                                  texture_discard, current_discard, getVolume()->getSculptLevel(),
-                                                                          mSculptTexture->getHeight(), mSculptTexture->getWidth()));
+                                                                                  mSculptTexture->getHeight(), mSculptTexture->getWidth()));
                        }
+                }
        }
@@ -538,10 +548,10 @@ void LLVOVolume::updateTextures()
        {
                setDebugText(llformat("%.0f:%.0f", fsqrtf(min_vsize),fsqrtf(max_vsize)));
        }
-        else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
+//      else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
-        {
+//      {
-                setDebugText(llformat("%.0f:%.0f", fsqrtf(min_vsize),fsqrtf(max_vsize)));
+//              setDebugText(llformat("%.0f:%.0f", fsqrtf(min_vsize),fsqrtf(max_vsize)));
-        }
+//      }
        else if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_FACE_AREA))
        {
                setDebugText(llformat("%.0f:%.0f", fsqrtf(min_vsize),fsqrtf(max_vsize)));
@@ -553,36 +563,6 @@ void LLVOVolume::updateTextures()
        }
 }
-F32 LLVOVolume::getTextureVirtualSize(LLFace* face)
-{
-        //get area of circle around face
-        LLVector3 center = face->getPositionAgent();
-        LLVector3 size = (face->mExtents[1] - face->mExtents[0]) * 0.5f;
-        
-        F32 face_area = LLPipeline::calcPixelArea(center, size, *LLViewerCamera::getInstance());
-        face->setPixelArea(face_area);
-        if (face_area <= 0)
-        {
-                return 0.f;
-        }
-        //get area of circle in texture space
-        LLVector2 tdim = face->mTexExtents[1] - face->mTexExtents[0];
-        F32 texel_area = (tdim * 0.5f).lengthSquared()*3.14159f;
-        if (texel_area <= 0)
-        {
-                // Probably animated, use default
-                texel_area = 1.f;
-        }
-        //apply texel area to face area to get accurate ratio
-        face_area /= llclamp(texel_area, 1.f/64.f, 16.f);
-        return face_area;
-}
 BOOL LLVOVolume::isActive() const
 {
        return !mStatic || mTextureAnimp || (mVolumeImpl && mVolumeImpl->isActive());
@@ -719,31 +699,21 @@ BOOL LLVOVolume::setVolume(const LLVolumeParams &volume_params, const S32 detail
 // sculpt replaces generate() for sculpted surfaces
 void LLVOVolume::sculpt()
-{
+{       
-        U16 sculpt_height = 0;
-        U16 sculpt_width = 0;
-        S8 sculpt_components = 0;
-        const U8* sculpt_data = NULL;
        if (mSculptTexture.notNull())
-        {
+        {                               
-                S32 discard_level;
+                U16 sculpt_height = 0;
-                S32 desired_discard = 0; // lower discard levels have MUCH less resolution 
+                U16 sculpt_width = 0;
+                S8 sculpt_components = 0;
-                discard_level = desired_discard;
+                const U8* sculpt_data = NULL;
+        
+                S32 discard_level = mSculptTexture->getCachedRawImageLevel() ;
+                LLImageRaw* raw_image = mSculptTexture->getCachedRawImage() ;
                
                S32 max_discard = mSculptTexture->getMaxDiscardLevel();
                if (discard_level > max_discard)
                        discard_level = max_discard;    // clamp to the best we can do
-                S32 best_discard = mSculptTexture->getDiscardLevel();
-                if (discard_level < best_discard)
-                        discard_level = best_discard;   // clamp to what we have
-                if (best_discard == -1)
-                        discard_level = -1;  // and if we have nothing, set to nothing
-                
                S32 current_discard = getVolume()->getSculptLevel();
                if(current_discard < -2)
                {
@@ -765,28 +735,17 @@ void LLVOVolume::sculpt()
                if (current_discard == discard_level)  // no work to do here
                        return;
                
-                LLPointer<LLImageRaw> raw_image = new LLImageRaw();
+                if(!raw_image)
-                BOOL is_valid = mSculptTexture->readBackRaw(discard_level, raw_image, FALSE);
-                sculpt_height = raw_image->getHeight();
-                sculpt_width = raw_image->getWidth();
-                sculpt_components = raw_image->getComponents();         
-                if(is_valid)
-                {
-                        is_valid = mSculptTexture->isValidForSculpt(discard_level, sculpt_width, sculpt_height, sculpt_components) ;
-                }
-                if(!is_valid)
                {
                        sculpt_width = 0;
                        sculpt_height = 0;
                        sculpt_data = NULL ;
                }
                else
-                {
+                {                                       
-                        if (raw_image->getDataSize() < sculpt_height * sculpt_width * sculpt_components)
+                        sculpt_height = raw_image->getHeight();
-                                llerrs << "Sculpt: image data size = " << raw_image->getDataSize()
+                        sculpt_width = raw_image->getWidth();
-                                           << " < " << sculpt_height << " x " << sculpt_width << " x " <<sculpt_components << llendl;
+                        sculpt_components = raw_image->getComponents();         
                                           
                        sculpt_data = raw_image->getData();
                }
@@ -818,7 +777,7 @@ BOOL LLVOVolume::calcLOD()
        }
        //update face texture sizes on lod calculation
-        updateTextures();
+        updateTextureVirtualSize();
        S32 cur_detail = 0;
        
@@ -2295,7 +2254,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
                LLVOVolume* vobj = drawablep->getVOVolume();
                llassert_always(vobj);
-                vobj->updateTextures();
+                vobj->updateTextureVirtualSize();
                vobj->preRebuild();
                //for each face
@@ -2399,7 +2358,7 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
                                                { //needs normal + binormal
                                                        bump_faces.push_back(facep);
                                                }
-                                                else if (te->getShiny() && LLPipeline::sRenderBump ||
+                                                else if ((te->getShiny() && LLPipeline::sRenderBump) ||
                                                        !te->getFullbright())
                                                { //needs normal
                                                        simple_faces.push_back(facep);
diff --git a/linden/indra/newview/llvovolume.h b/linden/indra/newview/llvovolume.h
index 9b4e715..960f6da 100644
--- a/linden/indra/newview/llvovolume.h
+++ b/linden/indra/newview/llvovolume.h
@@ -130,7 +130,7 @@ public:
                                
                                BOOL    getVolumeChanged() const                                { return mVolumeChanged; }
-                                F32             getTextureVirtualSize(LLFace* face);
+                                
        /*virtual*/ F32         getRadius() const                                               { return mVObjRadius; };
                                const LLMatrix4& getWorldMatrix(LLXformMatrix* xform) const;
@@ -177,8 +177,8 @@ public:
        /*virtual*/ void        updateFaceSize(S32 idx);
        /*virtual*/ BOOL        updateLOD();
                                void    updateRadius();
-        /*virtual*/ void        updateTextures(LLAgent &agent);
+        /*virtual*/ void        updateTextures();
-                                void    updateTextures();
+                                void    updateTextureVirtualSize();
                                void    updateFaceFlags();
                                void    regenFaces();
diff --git a/linden/indra/newview/llvowater.cpp b/linden/indra/newview/llvowater.cpp
index d23c746..5b6a949 100644
--- a/linden/indra/newview/llvowater.cpp
+++ b/linden/indra/newview/llvowater.cpp
@@ -101,7 +101,7 @@ void LLVOWater::setPixelAreaAndAngle(LLAgent &agent)
 // virtual
-void LLVOWater::updateTextures(LLAgent &agent)
+void LLVOWater::updateTextures()
 {
 }
diff --git a/linden/indra/newview/llvowater.h b/linden/indra/newview/llvowater.h
index cdda48f..9c33e74 100644
--- a/linden/indra/newview/llvowater.h
+++ b/linden/indra/newview/llvowater.h
@@ -68,7 +68,7 @@ public:
        /*virtual*/ BOOL        updateGeometry(LLDrawable *drawable);
        /*virtual*/ void                updateSpatialExtents(LLVector3& newMin, LLVector3& newMax);
-        /*virtual*/ void updateTextures(LLAgent &agent);
+        /*virtual*/ void updateTextures();
        /*virtual*/ void setPixelAreaAndAngle(LLAgent &agent); // generate accurate apparent angle and area
        virtual U32 getPartitionType() const;
diff --git a/linden/indra/newview/llworldmapview.cpp b/linden/indra/newview/llworldmapview.cpp
index 64e84c5..c10faa5 100644
--- a/linden/indra/newview/llworldmapview.cpp
+++ b/linden/indra/newview/llworldmapview.cpp
@@ -378,7 +378,7 @@ void LLWorldMapView::draw()
                        continue;
                }
                
-                current_image->setBoostLevel(LLViewerImage::BOOST_MAP_LAYER);
+                current_image->setBoostLevel(LLViewerImageBoostLevel::BOOST_MAP_VISIBLE);
                current_image->setKnownDrawSize(llround(pix_width * LLUI::sGLScaleFactor.mV[VX]), llround(pix_height * LLUI::sGLScaleFactor.mV[VY]));
                
                if (!current_image->getHasGLTexture())
@@ -557,13 +557,13 @@ void LLWorldMapView::draw()
                S32 draw_size = llround(gMapScale);
                if (simimage != NULL)
                {
-                        simimage->setBoostLevel(LLViewerImage::BOOST_MAP);
+                        simimage->setBoostLevel(LLViewerImageBoostLevel::BOOST_MAP);
                        simimage->setKnownDrawSize(llround(draw_size * LLUI::sGLScaleFactor.mV[VX]), llround(draw_size * LLUI::sGLScaleFactor.mV[VY]));
                }
                if (overlayimage != NULL)
                {
-                        overlayimage->setBoostLevel(LLViewerImage::BOOST_MAP);
+                        overlayimage->setBoostLevel(LLViewerImageBoostLevel::BOOST_MAP);
                        overlayimage->setKnownDrawSize(llround(draw_size * LLUI::sGLScaleFactor.mV[VX]), llround(draw_size * LLUI::sGLScaleFactor.mV[VY]));
                }
                        
diff --git a/linden/indra/newview/primbackup.cpp b/linden/indra/newview/primbackup.cpp
index 4f93ddf..a9a8af7 100644
--- a/linden/indra/newview/primbackup.cpp
+++ b/linden/indra/newview/primbackup.cpp
@@ -590,8 +590,8 @@ void primbackup::export_next_texture()
                        S32 cur_discard = imagep->getDiscardLevel();
                        if(cur_discard>0)
                        {
-                                if(imagep->getBoostLevel()!=LLViewerImage::BOOST_PREVIEW)
+                                if(imagep->getBoostLevel()!=LLViewerImageBoostLevel::BOOST_PREVIEW)
-                                        imagep->setBoostLevel(LLViewerImage::BOOST_PREVIEW); //we want to force discard 0 this one does this.
+                                        imagep->setBoostLevel(LLViewerImageBoostLevel::BOOST_PREVIEW); //we want to force discard 0 this one does this.
                        }
                        else
                        {