1 files changed, 264 insertions, 103 deletions

diff --git a/linden/indra/newview/llviewerimage.cpp b/linden/indra/newview/llviewerimage.cpp
index 400fb2f..93c17a2 100644
--- a/linden/indra/newview/llviewerimage.cpp
+++ b/linden/indra/newview/llviewerimage.cpp
@@ -60,6 +60,8 @@
 #include "pipeline.h"
 #include "llappviewer.h"
 #include "llface.h"
+#include "lltextureatlas.h"
+#include "lltextureatlasmanager.h"
 #include "llviewercamera.h"
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -102,7 +104,7 @@ 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, 0, TRUE, LLViewerImageBoostLevel::OTHER);
+        sNullImagep->createGLTexture(0, raw);
 
 #if 1
         LLPointer<LLViewerImage> imagep = new LLViewerImage(IMG_DEFAULT);
@@ -131,7 +133,7 @@ void LLViewerImage::initClass()
                         }
                 }
         }
-        imagep->createGLTexture(0, image_raw, 0, TRUE, LLViewerImageBoostLevel::OTHER);
+        imagep->createGLTexture(0, image_raw);
         image_raw = NULL;
         gImageList.addImage(imagep);
         imagep->dontDiscard();
@@ -141,48 +143,48 @@ void LLViewerImage::initClass()
         sSmokeImagep = gImageList.getImage(IMG_SMOKE, TRUE, TRUE);
         sSmokeImagep->setNoDelete() ;
 
-        if(gAuditTexture)
+#if !LL_RELEASE_FOR_DOWNLOAD
+        sDefaultTexturep = new LLImageGL() ;
+        image_raw = new LLImageRaw(dim,dim,3);
+        data = image_raw->getData();
+        for (S32 i = 0; i<dim; i++)
         {
-                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++)
                 {
-                        for (S32 j = 0; j<dim; j++)
+                        const S32 border = 2;
+                        if (i<border || j<border || i>=(dim-border) || j>=(dim-border))
                         {
-                                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;
-                                }
+                                *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();
         }
+        sDefaultTexturep->createGLTexture(0, image_raw);
+        image_raw = NULL;
+        sDefaultTexturep->dontDiscard();
+#endif
 }
 
 // static
 void LLViewerImage::cleanupClass()
 {
         stop_glerror();
-        LLImageGL::cleanupClass() ;
-
         sNullImagep = NULL;
         sDefaultImagep = NULL;
         sSmokeImagep = NULL;
         sMissingAssetImagep = NULL;
-        sWhiteImagep = NULL;    
-        sDefaultTexturep = NULL ;
+        sWhiteImagep = NULL;
+
+#if !LL_RELEASE_FOR_DOWNLOAD
+        LLImageGL::sDefaultTexturep = NULL ;
+#endif
 }
 
 // tuning params
@@ -231,12 +233,7 @@ 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) ;
+        LLImageGL::sUseTextureAtlas = gSavedSettings.getBOOL("EnableTextureAtlas") ;
 }
 
 // static
@@ -382,6 +379,7 @@ LLViewerImage::~LLViewerImage()
 void LLViewerImage::cleanup()
 {
         mFaceList.clear() ;
+
         for(callback_list_t::iterator iter = mLoadedCallbackList.begin();
                 iter != mLoadedCallbackList.end(); )
         {
@@ -411,6 +409,192 @@ void LLViewerImage::reinit(BOOL usemipmaps /* = TRUE */)
         setSize(0,0,0);
 }
 
+void LLViewerImage::resetFaceAtlas()
+{
+        //Nothing should be done here.
+}
+
+//invalidate all atlas slots for this image.
+void LLViewerImage::invalidateAtlas(BOOL rebuild_geom)
+{
+        for(ll_face_list_t::iterator iter = mFaceList.begin(); iter != mFaceList.end(); ++iter)
+        {
+                if(*iter)
+                {
+                        LLFace* facep = (LLFace*)*iter ;
+                        facep->removeAtlas() ;
+                        if(rebuild_geom && facep->getDrawable() && facep->getDrawable()->getSpatialGroup())
+                        {
+                                facep->getDrawable()->getSpatialGroup()->setState(LLSpatialGroup::GEOM_DIRTY);
+                        }
+                }
+        }
+}
+
+BOOL LLViewerImage::insertToAtlas()
+{
+        if(mFaceList.size() < 1)
+        {
+                return FALSE ;
+        }                                       
+        if(!canAddToAtlas())
+        {
+                return FALSE ;
+        }
+        if(getDiscardLevelInAtlas() > 0 && mRawDiscardLevel >= getDiscardLevelInAtlas())
+        {
+                return FALSE ;
+        }
+        if(!LLTextureAtlasManager::getInstance()->canAddToAtlas(mRawImage->getWidth(), mRawImage->getHeight(), mRawImage->getComponents(), getTexTarget()))
+        {
+                return FALSE ;
+        }
+
+        BOOL ret = TRUE ;//if ret is set to false, will generate a gl texture for this image.
+        S32 raw_w = mRawImage->getWidth() ;
+        S32 raw_h = mRawImage->getHeight() ;
+        F32 xscale = 1.0f, yscale = 1.0f ;
+        LLPointer<LLTextureAtlasSlot> slot_infop;
+        LLTextureAtlasSlot* cur_slotp ;//no need to be smart pointer.
+        LLSpatialGroup* groupp ;
+        LLFace* facep;
+
+        //if the atlas slot pointers for some faces are null, process them later.
+        ll_face_list_t waiting_list ;
+
+        for(ll_face_list_t::iterator iter = mFaceList.begin(); iter != mFaceList.end(); ++iter)
+        {
+                if(*iter)
+                {
+                        facep = (LLFace*)*iter ;
+                        
+                        //face can not use atlas.
+                        if(!facep->canUseAtlas())
+                        {
+                                if(facep->getAtlasInfo())
+                                {
+                                        facep->removeAtlas() ;  
+                                }
+                                ret = FALSE ;
+                                continue ;
+                        }
+
+                        //the atlas slot is updated
+                        slot_infop = facep->getAtlasInfo() ;
+                        groupp = facep->getDrawable()->getSpatialGroup() ;      
+
+                        if(slot_infop) 
+                        {
+                                if(slot_infop->getSpatialGroup() != groupp)
+                                {
+                                        if((cur_slotp = groupp->getCurUpdatingSlot(this))) //switch slot
+                                        {
+                                                facep->setAtlasInfo(cur_slotp) ;
+                                                facep->setAtlasInUse(TRUE) ;
+                                                continue ;
+                                        }
+                                        else //do not forget to update slot_infop->getSpatialGroup().
+                                        {
+                                                LLSpatialGroup* gp = slot_infop->getSpatialGroup() ;
+                                                gp->setCurUpdatingTime(gFrameCount) ;
+                                                gp->setCurUpdatingTexture(this) ;
+                                                gp->setCurUpdatingSlot(slot_infop) ;
+                                        }
+                                }
+                                else //same group
+                                {
+                                        if(gFrameCount && slot_infop->getUpdatedTime() == gFrameCount)//slot is just updated
+                                        {
+                                                facep->setAtlasInUse(TRUE) ;
+                                                continue ;
+                                        }
+                                }
+                        }                               
+                        else
+                        {
+                                //if the slot is null, wait to process them later.
+                                waiting_list.push_back(facep) ;
+                                continue ;
+                        }
+                                                
+                        //----------
+                        //insert to atlas
+                        if(!LLImageGL::createGLTextureInAtlas(mRawDiscardLevel, mRawImage, slot_infop->getAtlas(), slot_infop->getSlotCol(), slot_infop->getSlotRow()))
+                        {
+                                //the texture does not qualify to add to atlas, do not bother to try for other faces.
+                                //invalidateAtlas();
+                                return FALSE ;
+                        }
+                        
+                        //update texture scale          
+                        slot_infop->getAtlas()->getTexCoordScale(raw_w, raw_h, xscale, yscale) ;
+                        slot_infop->setTexCoordScale(xscale, yscale) ;
+                        slot_infop->setValid() ;
+                        slot_infop->setUpdatedTime(gFrameCount) ;
+                        
+                        //update spatial group atlas info
+                        groupp->setCurUpdatingTime(gFrameCount) ;
+                        groupp->setCurUpdatingTexture(this) ;
+                        groupp->setCurUpdatingSlot(slot_infop) ;
+
+                        //make the face to switch to the atlas.
+                        facep->setAtlasInUse(TRUE) ;
+                }
+        }
+
+        //process the waiting_list
+        for(ll_face_list_t::iterator iter = waiting_list.begin(); iter != waiting_list.end(); ++iter)
+        {
+                facep = (LLFace*)*iter ;        
+                groupp = facep->getDrawable()->getSpatialGroup() ;
+
+                //check if this texture already inserted to atlas for this group
+                if((cur_slotp = groupp->getCurUpdatingSlot(this)))
+                {
+                        facep->setAtlasInfo(cur_slotp) ;
+                        facep->setAtlasInUse(TRUE) ;            
+                        continue ;
+                }
+
+                //need to reserve a slot from atlas
+                slot_infop = LLTextureAtlasManager::getInstance()->reserveAtlasSlot(llmax(mFullWidth, mFullHeight), getComponents(), groupp, this) ;    
+
+                facep->setAtlasInfo(slot_infop) ;
+                
+                groupp->setCurUpdatingTime(gFrameCount) ;
+                groupp->setCurUpdatingTexture(this) ;
+                groupp->setCurUpdatingSlot(slot_infop) ;
+
+                //slot allocation failed.
+                if(!slot_infop || !slot_infop->getAtlas())
+                {                       
+                        ret = FALSE ;
+                        facep->setAtlasInUse(FALSE) ;
+                        continue ;
+                }
+                                
+                //insert to atlas
+                if(!LLImageGL::createGLTextureInAtlas(mRawDiscardLevel, mRawImage, slot_infop->getAtlas(), slot_infop->getSlotCol(), slot_infop->getSlotRow()))
+                {
+                        //the texture does not qualify to add to atlas, do not bother to try for other faces.
+                        ret = FALSE ;
+                        //invalidateAtlas();
+                        break ; 
+                }
+                
+                //update texture scale          
+                slot_infop->getAtlas()->getTexCoordScale(raw_w, raw_h, xscale, yscale) ;
+                slot_infop->setTexCoordScale(xscale, yscale) ;
+                slot_infop->setValid() ;
+                slot_infop->setUpdatedTime(gFrameCount) ;
+
+                //make the face to switch to the atlas.
+                facep->setAtlasInUse(TRUE) ;
+        }
+        
+        return ret ;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // ONLY called from LLViewerImageList
 void LLViewerImage::destroyTexture() 
@@ -432,7 +616,7 @@ void LLViewerImage::addToCreateTexture()
         if(isForSculptOnly())
         {
                 //just update some variables, not to create a real GL texture.
-                createGLTexture(mRawDiscardLevel, mRawImage, 0, FALSE) ;
+                createGLTexture(mRawDiscardLevel, mRawImage, 0) ;
                 mNeedsCreateTexture = FALSE ;
                 destroyRawImage();
         }
@@ -495,7 +679,7 @@ BOOL LLViewerImage::createTexture(S32 usename/*= 0*/)
         mNeedsCreateTexture     = FALSE;
         if (mRawImage.isNull())
         {
-                llerrs << "LLViewerImage trying to create texture with no Raw Image" << llendl;
+                llwarns << "LLViewerImage trying to create texture with no Raw Image" << llendl;
         }
 //      llinfos << llformat("IMAGE Creating (%d) [%d x %d] Bytes: %d ",
 //                                              mRawDiscardLevel, 
@@ -519,32 +703,25 @@ BOOL LLViewerImage::createTexture(S32 usename/*= 0*/)
                         mOrigHeight = mFullHeight;
                 }
 
-                bool size_okay = true;
-                
-                U32 raw_width = mRawImage->getWidth() << mRawDiscardLevel;
-                U32 raw_height = mRawImage->getHeight() << mRawDiscardLevel;
-                if( raw_width > MAX_IMAGE_SIZE || raw_height > MAX_IMAGE_SIZE )
+                if (LLImageGL::checkSize(mRawImage->getWidth(), mRawImage->getHeight()))
                 {
-                        llinfos << "Width or height is greater than " << MAX_IMAGE_SIZE << ": (" << raw_width << "," << raw_height << ")" << llendl;
-                        size_okay = false;
+                        if(!(res = insertToAtlas()))
+                        {
+                                res = LLImageGL::createGLTexture(mRawDiscardLevel, mRawImage, usename);
+                                resetFaceAtlas() ;
+                        }
                 }
                 
-                if (!LLImageGL::checkSize(mRawImage->getWidth(), mRawImage->getHeight()))
+                else
                 {
                         // A non power-of-two image was uploaded (through a non standard client)
-                        llinfos << "Non power of two width or height: (" << mRawImage->getWidth() << "," << mRawImage->getHeight() << ")" << llendl;
-                        size_okay = false;
-                }
-                
-                if( !size_okay )
-                {
-                        // An inappropriately-sized image was uploaded (through a non standard client)
                         // We treat these images as missing assets which causes them to
                         // be renderd as 'missing image' and to stop requesting data
                         setIsMissingAsset();
                         destroyRawImage();
                         return FALSE;
                 }
+
                 if (mRawImage->getComponents()>4)
                 {
                         LL_DEBUGS("Openjpeg")<<"broken raw image" << LL_ENDL;
@@ -553,7 +730,6 @@ BOOL LLViewerImage::createTexture(S32 usename/*= 0*/)
                         return FALSE;
                 }
 
-                res = LLImageGL::createGLTexture(mRawDiscardLevel, mRawImage, usename);
         }
 
         //
@@ -655,6 +831,7 @@ 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
@@ -662,7 +839,8 @@ void LLViewerImage::processTextureStats()
                 // data than we need to.
                 if (mBoostLevel == LLViewerImageBoostLevel::BOOST_UI ||
                         mBoostLevel == LLViewerImageBoostLevel::BOOST_PREVIEW ||
-                        mBoostLevel == LLViewerImageBoostLevel::BOOST_AVATAR_SELF)      // JAMESDEBUG what about AVATAR_BAKED_SELF?
+                        mBoostLevel == LLViewerImageBoostLevel::BOOST_AVATAR_SELF ||
+                        mBoostLevel == LLViewerImageBoostLevel::BOOST_AVATAR_BAKED_SELF) 
                 {
                         discard_level = 0; // full res
                 }
@@ -677,12 +855,6 @@ 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))
                         {
@@ -705,6 +877,7 @@ void LLViewerImage::processTextureStats()
                         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)
@@ -726,15 +899,12 @@ void LLViewerImage::processTextureStats()
                 if ((sDesiredDiscardBias > 0.0f) &&
                         (current_discard >= 0 && mDesiredDiscardLevel >= current_discard))
                 {
-                        // Limit the amount of GL memory bound each frame
-                        if ( (BYTES_TO_MEGA_BYTES(sBoundTextureMemoryInBytes) > sMaxBoundTextureMemInMegaBytes * texmem_middle_bound_scale) &&
-                                (!getBoundRecently() || mDesiredDiscardLevel >= mCachedRawDiscardLevel))
+                        if ( (sBoundTextureMemoryInBytes >> 20) > sMaxBoundTextureMemInMegaBytes*texmem_middle_bound_scale)
                         {
                                 scaleDown() ;
                         }
                         // 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))
+                        else if (!getBoundRecently() || mDesiredDiscardLevel >= mCachedRawDiscardLevel)
                         {
                                 scaleDown() ;
                         }
@@ -756,7 +926,7 @@ void LLViewerImage::updateVirtualSize()
                         if(facep->getDrawable()->isRecentlyVisible())
                         {
                                 addTextureStats(facep->getVirtualSize()) ;
-                                setAdditionalDecodePriority(facep->getImportanceToCamera()) ;
+                                //setAdditionalDecodePriority(facep->getImportanceToCamera()) ;
                         }
                 }       
         }
@@ -796,6 +966,7 @@ void LLViewerImage::switchToCachedImage()
                 mNeedsCreateTexture = TRUE;             
         }
 }
+
 //============================================================================
 
 F32 LLViewerImage::calcDecodePriority()
@@ -817,13 +988,6 @@ F32 LLViewerImage::calcDecodePriority()
         }
 
         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
@@ -842,14 +1006,6 @@ F32 LLViewerImage::calcDecodePriority()
         {
                 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
@@ -910,7 +1066,6 @@ F32 LLViewerImage::calcDecodePriority()
                         ddiscard-=2;
                 }
                 ddiscard = llclamp(ddiscard, 0, 4);
-
                 priority = ddiscard*100000.f;
         }
         if (priority > 0.0f)
@@ -942,7 +1097,7 @@ F32 LLViewerImage::calcDecodePriority()
 //static
 F32 LLViewerImage::maxDecodePriority()
 {
-        return 6000000.f;
+        return 6000000.f; // KL 2000000 in render pipeline 
 }
 
 void LLViewerImage::setDecodePriority(F32 priority)
@@ -969,10 +1124,7 @@ void LLViewerImage::setBoostLevel(S32 level)
 {       
         mBoostLevel = level;
 
-        if(gAuditTexture)
-        {
-                setCategory(mBoostLevel);
-        }
+
 
         if(mBoostLevel != LLViewerImageBoostLevel::BOOST_NONE)
         {
@@ -1022,11 +1174,15 @@ bool LLViewerImage::updateFetch()
                 return false; // process any raw image data in callbacks before replacing
         }
         
+        mFetchState = 0;
+        mFetchPriority = 0;
+        mFetchDeltaTime = 999999.f;
+        mRequestDeltaTime = 999999.f;
         S32 current_discard = getDiscardLevel();
         S32 desired_discard = getDesiredDiscardLevel();
         F32 decode_priority = getDecodePriority();
         decode_priority = llmax(decode_priority, 0.0f);
-        decode_priority = llmin(decode_priority, maxDecodePriority());
+        //decode_priority = llmin(decode_priority, maxDecodePriority());
         
         if (mIsFetching)
         {
@@ -1059,7 +1215,6 @@ bool LLViewerImage::updateFetch()
                 if (mRawImage.notNull())
                 {
                         mRawDiscardLevel = fetch_discard;
-                        
                         if ((mRawImage->getDataSize() > 0 && mRawDiscardLevel >= 0) &&
                                 (current_discard < 0 || mRawDiscardLevel < current_discard))
                         {
@@ -1178,10 +1333,6 @@ bool LLViewerImage::updateFetch()
         {
                 make_request = false;
         }
-        else if (!isJustBound() && mCachedRawImageReady)
-        {
-                make_request = false;
-        }
         else
         {
                 if (mIsFetching)
@@ -1216,14 +1367,13 @@ bool LLViewerImage::updateFetch()
                                                                                                                                                           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
@@ -1295,12 +1445,12 @@ BOOL LLViewerImage::forceFetch()
                                                                                                                                                   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);
+        //      gImageList.bumpToMaxDecodePriority(this); // Kl force immediate update??
                 mRequestedDiscardLevel = desired_discard ;
 
                 mFetchState = LLAppViewer::getTextureFetch()->getFetchState(mID, mDownloadProgress, mRequestedDownloadPriority,
@@ -1473,8 +1623,8 @@ bool LLViewerImage::doLoadedCallbacks()
 
                 destroyRawImage();
                 readBackRawImage(gl_discard);
-                llassert_always(mRawImage.notNull());
-                llassert_always(!mNeedsAux || mAuxRawImage.notNull());
+                //llassert_always(mRawImage.notNull());
+                //llassert_always(!mNeedsAux || mAuxRawImage.notNull());
         }
 
         //
@@ -1636,7 +1786,18 @@ bool LLViewerImage::bindDefaultImage(S32 stage)
 //virtual
 void LLViewerImage::forceImmediateUpdate()
 {
-        gImageList.bumpToMaxDecodePriority(this) ;
+        //only immediately update a deleted texture which is now being re-used.
+        if(!isDeleted())
+        {
+                return ;
+        }
+        //if already called forceImmediateUpdate()
+        if(mInImageList && mDecodePriority == LLViewerImage::maxDecodePriority())
+        {
+                return ;
+        }
+
+        gImageList.forceImmediateUpdate(this) ;
         return ;
 }
 
@@ -1647,7 +1808,7 @@ LLImageRaw* LLViewerImage::readBackRawImage(S8 discard_level)
         llassert_always(mComponents > 0);
         if (mRawImage.notNull())
         {
-                llerrs << "called with existing mRawImage" << llendl;
+                llwarns << "called with existing mRawImage" << llendl;
                 mRawImage = NULL;
         }
         
@@ -1665,7 +1826,7 @@ LLImageRaw* LLViewerImage::readBackRawImage(S8 discard_level)
 
         sRawCount++;    
         mIsRawImageValid = TRUE;
-
+        
         return mRawImage;
 }