1 files changed, 134 insertions, 302 deletions

diff --git a/indra/newview/llviewertexture.cpp b/indra/newview/llviewertexture.cpp
index c389d2122e..0c23214b52 100644
--- a/indra/newview/llviewertexture.cpp
+++ b/indra/newview/llviewertexture.cpp
@@ -58,6 +58,8 @@
 #include "llvovolume.h"
 #include "llviewermedia.h"
 #include "lltexturecache.h"
+#include "llviewerwindow.h"
+#include "llwindow.h"
 ///////////////////////////////////////////////////////////////////////////////
 
 // extern
@@ -76,6 +78,8 @@ LLPointer<LLViewerFetchedTexture> LLViewerFetchedTexture::sSmokeImagep = NULL;
 LLPointer<LLViewerFetchedTexture> LLViewerFetchedTexture::sFlatNormalImagep = NULL;
 LLViewerMediaTexture::media_map_t LLViewerMediaTexture::sMediaMap;
 LLTexturePipelineTester* LLViewerTextureManager::sTesterp = NULL;
+F32 LLViewerFetchedTexture::sMaxVirtualSize = F32_MAX/2.f;
+
 const std::string sTesterName("TextureTester");
 
 S32 LLViewerTexture::sImageCount = 0;
@@ -84,11 +88,6 @@ S32 LLViewerTexture::sAuxCount = 0;
 LLFrameTimer LLViewerTexture::sEvaluationTimer;
 F32 LLViewerTexture::sDesiredDiscardBias = 0.f;
 F32 LLViewerTexture::sDesiredDiscardScale = 1.1f;
-S32Bytes LLViewerTexture::sBoundTextureMemory;
-S32Bytes LLViewerTexture::sTotalTextureMemory;
-S32Megabytes LLViewerTexture::sMaxBoundTextureMemory;
-S32Megabytes LLViewerTexture::sMaxTotalTextureMem;
-S32Bytes LLViewerTexture::sMaxDesiredTextureMem;
 S8  LLViewerTexture::sCameraMovingDiscardBias = 0;
 F32 LLViewerTexture::sCameraMovingBias = 0.0f;
 S32 LLViewerTexture::sMaxSculptRez = 128; //max sculpt image size
@@ -471,11 +470,6 @@ void LLViewerTextureManager::cleanup()
 void LLViewerTexture::initClass()
 {
 	LLImageGL::sDefaultGLTexture = LLViewerFetchedTexture::sDefaultImagep->getGLTexture();
-	
-	if(gSavedSettings.getBOOL("TextureFetchDebuggerEnabled"))
-	{
-		sTexelPixelRatio = gSavedSettings.getF32("TexelPixelRatio");
-	}
 }
 
 // tuning params
@@ -500,7 +494,7 @@ bool LLViewerTexture::isMemoryForTextureLow()
     S32Megabytes physical;
     getGPUMemoryForTextures(gpu, physical);
 
-    return (gpu < MIN_FREE_TEXTURE_MEMORY) || (physical < MIN_FREE_MAIN_MEMORY);
+    return (gpu < MIN_FREE_TEXTURE_MEMORY); // || (physical < MIN_FREE_MAIN_MEMORY);
 }
 
 //static
@@ -514,7 +508,7 @@ bool LLViewerTexture::isMemoryForTextureSuficientlyFree()
     S32Megabytes physical;
     getGPUMemoryForTextures(gpu, physical);
 
-    return (gpu > DESIRED_FREE_TEXTURE_MEMORY) && (physical > DESIRED_FREE_MAIN_MEMORY);
+    return (gpu > DESIRED_FREE_TEXTURE_MEMORY); // && (physical > DESIRED_FREE_MAIN_MEMORY);
 }
 
 //static
@@ -535,9 +529,9 @@ void LLViewerTexture::getGPUMemoryForTextures(S32Megabytes &gpu, S32Megabytes &p
     timer.reset();
 
     {
-        gpu_res = (S32Megabytes) LLImageGLThread::getFreeVRAMMegabytes();
+        gpu_res = (S32Megabytes)gViewerWindow->getWindow()->getAvailableVRAMMegabytes();
         
-        //check main memory, only works for windows.
+        //check main memory, only works for windows and macos.
         LLMemory::updateMemoryInfo();
         physical_res = LLMemory::getAvailableMemKB();
 
@@ -560,27 +554,7 @@ void LLViewerTexture::updateClass()
 
 	LLViewerMediaTexture::updateClass();
 
-	sBoundTextureMemory = LLImageGL::sBoundTextureMemory;
-	sTotalTextureMemory = LLImageGL::sGlobalTextureMemory;
-	sMaxBoundTextureMemory = gTextureList.getMaxResidentTexMem();
-	sMaxTotalTextureMem = gTextureList.getMaxTotalTextureMem();
-	sMaxDesiredTextureMem = sMaxTotalTextureMem; //in Bytes, by default and when total used texture memory is small.
-
-	if (sBoundTextureMemory >= sMaxBoundTextureMemory ||
-		sTotalTextureMemory >= sMaxTotalTextureMem)
-	{
-		//when texture memory overflows, lower down the threshold to release the textures more aggressively.
-		sMaxDesiredTextureMem = llmin(sMaxDesiredTextureMem * 0.75f, F32Bytes(gMaxVideoRam));
-	
-		// If we are using more texture memory than we should,
-		// scale up the desired discard level
-		if (sEvaluationTimer.getElapsedTimeF32() > discard_delta_time)
-		{
-			sDesiredDiscardBias += discard_bias_delta;
-			sEvaluationTimer.reset();
-		}
-	}
-	else if(isMemoryForTextureLow())
+	if(isMemoryForTextureLow())
 	{
 		// Note: isMemoryForTextureLow() uses 1s delay, make sure we waited enough for it to recheck
 		if (sEvaluationTimer.getElapsedTimeF32() > GPU_MEMORY_CHECK_WAIT_TIME)
@@ -590,8 +564,6 @@ void LLViewerTexture::updateClass()
 		}
 	}
 	else if (sDesiredDiscardBias > 0.0f
-			 && sBoundTextureMemory < sMaxBoundTextureMemory * texmem_lower_bound_scale
-			 && sTotalTextureMemory < sMaxTotalTextureMem * texmem_lower_bound_scale
 			 && isMemoryForTextureSuficientlyFree())
 	{
 		// If we are using less texture memory than we should,
@@ -661,7 +633,6 @@ void LLViewerTexture::init(bool firstinit)
 	mMaxVirtualSize = 0.f;
 	mMaxVirtualSizeResetInterval = 1;
 	mMaxVirtualSizeResetCounter = mMaxVirtualSizeResetInterval;
-	mAdditionalDecodePriority = 0.f;	
 	mParcelMedia = NULL;
 	
 	memset(&mNumVolumes, 0, sizeof(U32)* LLRender::NUM_VOLUME_TEXTURE_CHANNELS);
@@ -689,6 +660,11 @@ void LLViewerTexture::cleanup()
 {
 	notifyAboutMissingAsset();
 
+    if (LLAppViewer::getTextureFetch())
+    {
+        LLAppViewer::getTextureFetch()->updateRequestPriority(mID, 0.f);
+    }
+
 	mFaceList[LLRender::DIFFUSE_MAP].clear();
 	mFaceList[LLRender::NORMAL_MAP].clear();
 	mFaceList[LLRender::SPECULAR_MAP].clear();
@@ -745,6 +721,12 @@ void LLViewerTexture::setBoostLevel(S32 level)
 		}
 	}
 
+    // strongly encourage anything boosted to load at full res
+    if (mBoostLevel >= LLViewerTexture::BOOST_HIGH)
+    {
+        mMaxVirtualSize = 2048.f * 2048.f;
+    }
+
 	if (mBoostLevel == LLViewerTexture::BOOST_SELECTED)
 	{
 		mSelectedTime = gFrameTimeSeconds;
@@ -828,15 +810,8 @@ void LLViewerTexture::addTextureStats(F32 virtual_size, BOOL needs_gltexture) co
 	}
 
 	virtual_size *= sTexelPixelRatio;
-	if(!mMaxVirtualSizeResetCounter)
-	{
-		//flag to reset the values because the old values are used.
-		resetMaxVirtualSizeResetCounter();
-		mMaxVirtualSize = virtual_size;
-		mAdditionalDecodePriority = 0.f;
-		mNeedsGLTexture = needs_gltexture;
-	}
-	else if (virtual_size > mMaxVirtualSize)
+
+	if (virtual_size > mMaxVirtualSize)
 	{
 		mMaxVirtualSize = virtual_size;
 	}
@@ -845,7 +820,6 @@ void LLViewerTexture::addTextureStats(F32 virtual_size, BOOL needs_gltexture) co
 void LLViewerTexture::resetTextureStats()
 {
 	mMaxVirtualSize = 0.0f;
-	mAdditionalDecodePriority = 0.f;	
 	mMaxVirtualSizeResetCounter = 0;
 }
 
@@ -1114,7 +1088,6 @@ void LLViewerFetchedTexture::init(bool firstinit)
 
 	if (firstinit)
 	{
-		mDecodePriority = 0.f;
 		mInImageList = 0;
 	}
 
@@ -1163,6 +1136,7 @@ void LLViewerFetchedTexture::init(bool firstinit)
 
 LLViewerFetchedTexture::~LLViewerFetchedTexture()
 {
+    assert_main_thread();
 	//*NOTE getTextureFetch can return NULL when Viewer is shutting down.
 	// This is due to LLWearableList is singleton and is destroyed after 
 	// LLAppViewer::cleanup() was called. (see ticket EXT-177)
@@ -1359,10 +1333,7 @@ void LLViewerFetchedTexture::dump()
 void LLViewerFetchedTexture::destroyTexture() 
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
-	if(LLImageGL::sGlobalTextureMemory < sMaxDesiredTextureMem * 0.95f)//not ready to release unused memory.
-	{
-		return ;
-	}
+
 	if (mNeedsCreateTexture)//return if in the process of generating a new texture.
 	{
 		return;
@@ -1598,6 +1569,7 @@ BOOL LLViewerFetchedTexture::createTexture(S32 usename/*= 0*/)
 
 void LLViewerFetchedTexture::postCreateTexture()
 {
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
     if (!mNeedsCreateTexture)
     {
         return;
@@ -1621,6 +1593,8 @@ void LLViewerFetchedTexture::postCreateTexture()
 
 void LLViewerFetchedTexture::scheduleCreateTexture()
 {
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
+
     if (!mNeedsCreateTexture)
     {
         mNeedsCreateTexture = TRUE;
@@ -1697,6 +1671,7 @@ void LLViewerFetchedTexture::scheduleCreateTexture()
 //virtual
 void LLViewerFetchedTexture::setKnownDrawSize(S32 width, S32 height)
 {
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
 	if(mKnownDrawWidth < width || mKnownDrawHeight < height)
 	{
 		mKnownDrawWidth = llmax(mKnownDrawWidth, width);
@@ -1708,9 +1683,31 @@ void LLViewerFetchedTexture::setKnownDrawSize(S32 width, S32 height)
 	addTextureStats((F32)(mKnownDrawWidth * mKnownDrawHeight));
 }
 
+void LLViewerFetchedTexture::setDebugText(const std::string& text)
+{
+    for (U32 ch = 0; ch < LLRender::NUM_TEXTURE_CHANNELS; ++ch)
+    {
+        llassert(mNumFaces[ch] <= mFaceList[ch].size());
+
+        for (U32 i = 0; i < mNumFaces[ch]; i++)
+        {
+            LLFace* facep = mFaceList[ch][i];
+            if (facep)
+            {
+                LLDrawable* drawable = facep->getDrawable();
+                if (drawable)
+                {
+                    drawable->getVObj()->setDebugText(text);
+                }
+            }
+        }
+    }
+}
+
 //virtual
 void LLViewerFetchedTexture::processTextureStats()
 {
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
 	if(mFullyLoaded)
 	{		
 		if(mDesiredDiscardLevel > mMinDesiredDiscardLevel)//need to load more
@@ -1718,6 +1715,7 @@ void LLViewerFetchedTexture::processTextureStats()
 			mDesiredDiscardLevel = llmin(mDesiredDiscardLevel, mMinDesiredDiscardLevel);
 			mFullyLoaded = FALSE;
 		}
+        //setDebugText("fully loaded");
 	}
 	else
 	{
@@ -1730,7 +1728,7 @@ void LLViewerFetchedTexture::processTextureStats()
 			mDesiredDiscardLevel = 0;
 		}
 		else if (!LLPipeline::sRenderDeferred && mBoostLevel == LLGLTexture::BOOST_ALM)
-		{
+		{ // ??? don't load spec and normal maps when alm is disabled ???
 			mDesiredDiscardLevel = MAX_DISCARD_LEVEL + 1;
 		}
         else if (mDontDiscard && mBoostLevel == LLGLTexture::BOOST_ICON)
@@ -1788,198 +1786,8 @@ void LLViewerFetchedTexture::processTextureStats()
 	}
 }
 
-const F32 MAX_PRIORITY_PIXEL                         = 999.f;     //pixel area
-const F32 PRIORITY_BOOST_LEVEL_FACTOR                = 1000.f;    //boost level
-const F32 PRIORITY_DELTA_DISCARD_LEVEL_FACTOR        = 100000.f;  //delta discard
-const S32 MAX_DELTA_DISCARD_LEVEL_FOR_PRIORITY       = 4;
-const F32 PRIORITY_ADDITIONAL_FACTOR                 = 1000000.f; //additional 
-const S32 MAX_ADDITIONAL_LEVEL_FOR_PRIORITY          = 8;
-const F32 PRIORITY_BOOST_HIGH_FACTOR                 = 10000000.f;//boost high
-F32 LLViewerFetchedTexture::calcDecodePriority()
-{
-#ifndef LL_RELEASE_FOR_DOWNLOAD
-	if (mID == LLAppViewer::getTextureFetch()->mDebugID)
-	{
-		LLAppViewer::getTextureFetch()->mDebugCount++; // for setting breakpoints
-	}
-#endif
-	
-	if (mNeedsCreateTexture)
-	{
-		return mDecodePriority; // no change while waiting to create
-	}
-	if(mFullyLoaded && !mForceToSaveRawImage)//already loaded for static texture
-	{
-		return -1.0f; //alreay fetched
-	}
-
-	S32 cur_discard = getCurrentDiscardLevelForFetching();
-	bool have_all_data = (cur_discard >= 0 && (cur_discard <= mDesiredDiscardLevel));
-	F32 pixel_priority = (F32) sqrt(mMaxVirtualSize);
-
-	F32 priority = 0.f;
-
-	if (mIsMissingAsset)
-	{
-		priority = 0.0f;
-	}
-	else if(mDesiredDiscardLevel >= cur_discard && cur_discard > -1)
-	{
-		priority = -2.0f;
-	}
-	else if(mCachedRawDiscardLevel > -1 && mDesiredDiscardLevel >= mCachedRawDiscardLevel)
-	{
-		priority = -3.0f;
-	}
-	else if (mDesiredDiscardLevel > getMaxDiscardLevel())
-	{
-		// Don't decode anything we don't need
-		priority = -4.0f;
-	}
-	else if ((mBoostLevel == LLGLTexture::BOOST_UI || mBoostLevel == LLGLTexture::BOOST_ICON) && !have_all_data)
-	{
-		priority = 1.f;
-	}
-	else if (pixel_priority < 0.001f && !have_all_data)
-	{
-		// Not on screen but we might want some data
-		if (mBoostLevel > BOOST_SELECTED)
-		{
-			// Always want high boosted images
-			priority = 1.f;
-		}
-		else
-		{
-			priority = -5.f; //stop fetching
-		}
-	}
-	else if (cur_discard < 0)
-	{
-		//texture does not have any data, so we don't know the size of the image, treat it like 32 * 32.
-		// priority range = 100,000 - 500,000
-		static const F64 log_2 = log(2.0);
-		F32 desired = (F32)(log(32.0/pixel_priority) / log_2);
-		S32 ddiscard = MAX_DISCARD_LEVEL - (S32)desired;
-		ddiscard = llclamp(ddiscard, 0, MAX_DELTA_DISCARD_LEVEL_FOR_PRIORITY);
-		priority = (ddiscard + 1) * PRIORITY_DELTA_DISCARD_LEVEL_FACTOR;
-		setAdditionalDecodePriority(0.1f);//boost the textures without any data so far.
-	}
-	else if ((mMinDiscardLevel > 0) && (cur_discard <= mMinDiscardLevel))
-	{
-		// larger mips are corrupted
-		priority = -6.0f;
-	}
-	else
-	{
-		// priority range = 100,000 - 500,000
-		S32 desired_discard = mDesiredDiscardLevel;
-		if (!isJustBound() && mCachedRawImageReady)
-		{
-			if(mBoostLevel < BOOST_HIGH)
-			{
-				// We haven't rendered this in a while, de-prioritize it
-				desired_discard += 2;
-			}
-			else
-			{
-				// We haven't rendered this in the last half second, and we have a cached raw image, leave the desired discard as-is
-				desired_discard = cur_discard;
-			}
-		}
-
-		S32 ddiscard = cur_discard - desired_discard;
-		ddiscard = llclamp(ddiscard, -1, MAX_DELTA_DISCARD_LEVEL_FOR_PRIORITY);
-		priority = (ddiscard + 1) * PRIORITY_DELTA_DISCARD_LEVEL_FACTOR;		
-	}
-
-	// Priority Formula:
-	// BOOST_HIGH  +  ADDITIONAL PRI + DELTA DISCARD + BOOST LEVEL + PIXELS
-	// [10,000,000] + [1,000,000-9,000,000]  + [100,000-500,000]   + [1-20,000]  + [0-999]
-	if (priority > 0.0f)
-	{
-		bool large_enough = mCachedRawImageReady && ((S32)mTexelsPerImage > sMinLargeImageSize);
-		if(large_enough)
-		{
-			//Note: 
-			//to give small, low-priority textures some chance to be fetched, 
-			//cut the priority in half if the texture size is larger than 256 * 256 and has a 64*64 ready.
-			priority *= 0.5f; 
-		}
-
-		pixel_priority = llclamp(pixel_priority, 0.0f, MAX_PRIORITY_PIXEL); 
-
-		priority += pixel_priority + PRIORITY_BOOST_LEVEL_FACTOR * mBoostLevel;
-
-		if ( mBoostLevel > BOOST_HIGH)
-		{
-			if(mBoostLevel > BOOST_SUPER_HIGH)
-			{
-				//for very important textures, always grant the highest priority.
-				priority += PRIORITY_BOOST_HIGH_FACTOR;
-			}
-			else if(mCachedRawImageReady)
-			{
-				//Note: 
-				//to give small, low-priority textures some chance to be fetched, 
-				//if high priority texture has a 64*64 ready, lower its fetching priority.
-				setAdditionalDecodePriority(0.5f);
-			}
-			else
-			{
-				priority += PRIORITY_BOOST_HIGH_FACTOR;
-			}
-		}		
-
-		if(mAdditionalDecodePriority > 0.0f)
-		{
-			// priority range += 1,000,000.f-9,000,000.f
-			F32 additional = PRIORITY_ADDITIONAL_FACTOR * (1.0 + mAdditionalDecodePriority * MAX_ADDITIONAL_LEVEL_FOR_PRIORITY);
-			if(large_enough)
-			{
-				//Note: 
-				//to give small, low-priority textures some chance to be fetched, 
-				//cut the additional priority to a quarter if the texture size is larger than 256 * 256 and has a 64*64 ready.
-				additional *= 0.25f;
-			}
-			priority += additional;
-		}
-	}
-	return priority;
-}
-
-//static
-F32 LLViewerFetchedTexture::maxDecodePriority()
-{
-	static const F32 max_priority = PRIORITY_BOOST_HIGH_FACTOR +                           //boost_high
-		PRIORITY_ADDITIONAL_FACTOR * (MAX_ADDITIONAL_LEVEL_FOR_PRIORITY + 1) +             //additional (view dependent factors)
-		PRIORITY_DELTA_DISCARD_LEVEL_FACTOR * (MAX_DELTA_DISCARD_LEVEL_FOR_PRIORITY + 1) + //delta discard
-		PRIORITY_BOOST_LEVEL_FACTOR * (BOOST_MAX_LEVEL - 1) +                              //boost level
-		MAX_PRIORITY_PIXEL + 1.0f;                                                        //pixel area.
-	
-	return max_priority;
-}
-
 //============================================================================
 
-void LLViewerFetchedTexture::setDecodePriority(F32 priority)
-{
-	mDecodePriority = priority;
-
-	if(mDecodePriority < F_ALMOST_ZERO)
-	{
-		mStopFetchingTimer.reset();
-	}
-}
-
-void LLViewerFetchedTexture::setAdditionalDecodePriority(F32 priority)
-{
-	priority = llclamp(priority, 0.f, 1.f);
-	if(mAdditionalDecodePriority < priority)
-	{
-		mAdditionalDecodePriority = priority;
-	}
-}
-
 void LLViewerFetchedTexture::updateVirtualSize() 
 {	
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
@@ -1988,6 +1796,18 @@ void LLViewerFetchedTexture::updateVirtualSize()
 		addTextureStats(0.f, FALSE);//reset
 	}
 
+    if (getBoostLevel() >= LLViewerTexture::BOOST_HIGH)
+    { //always load boosted textures at highest priority full res
+        addTextureStats(sMaxVirtualSize);
+        return;
+    }
+
+    if (sDesiredDiscardBias > 0.f)
+    {
+        // running out of video memory, don't hold onto high res textures in the background
+        mMaxVirtualSize = 0.f;
+    }
+
 	for (U32 ch = 0; ch < LLRender::NUM_TEXTURE_CHANNELS; ++ch)
 	{				
 		llassert(mNumFaces[ch] <= mFaceList[ch].size());
@@ -2009,8 +1829,12 @@ void LLViewerFetchedTexture::updateVirtualSize()
 						setBoostLevel(LLViewerTexture::BOOST_SELECTED);
 					}
 					addTextureStats(facep->getVirtualSize());
-					setAdditionalDecodePriority(facep->getImportanceToCamera());
+                    //drawable->getVObj()->setDebugText(llformat("%d:%d", (S32)sqrtf(facep->getVirtualSize()), (S32)sqrtf(getMaxVirtualSize())));
 				}
+                else
+                {
+                    //drawable->getVObj()->setDebugText("");
+                }
 			}
 		}
 	}
@@ -2072,6 +1896,16 @@ bool LLViewerFetchedTexture::isActiveFetching()
 	return mFetchState > 7 && mFetchState < 10 && monitor_enabled; //in state of WAIT_HTTP_REQ or DECODE_IMAGE.
 }
 
+void LLViewerFetchedTexture::setBoostLevel(S32 level)
+{
+    LLViewerTexture::setBoostLevel(level);
+
+    if (level >= LLViewerTexture::BOOST_HIGH)
+    {
+        mDesiredDiscardLevel = 0;
+    }
+}
+
 bool LLViewerFetchedTexture::updateFetch()
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
@@ -2098,31 +1932,40 @@ bool LLViewerFetchedTexture::updateFetch()
 
 	if (mNeedsCreateTexture)
 	{
+        LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - needs create");
 		// We may be fetching still (e.g. waiting on write)
 		// but don't check until we've processed the raw data we have
 		return false;
 	}
 	if (mIsMissingAsset)
 	{
+        LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - missing asset");
 		llassert_always(!mHasFetcher);
 		return false; // skip
 	}
 	if (!mLoadedCallbackList.empty() && mRawImage.notNull())
 	{
+        LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - callback pending");
 		return false; // process any raw image data in callbacks before replacing
 	}
 	if(mInFastCacheList)
 	{
+        LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - in fast cache");
 		return false;
 	}
+    if (mGLTexturep.isNull())
+    { // fix for crash inside getCurrentDiscardLevelForFetching (shouldn't happen but appears to be happening)
+        llassert(false);
+        return false;
+    }
 	
 	S32 current_discard = getCurrentDiscardLevelForFetching();
 	S32 desired_discard = getDesiredDiscardLevel();
-	F32 decode_priority = getDecodePriority();
-	decode_priority = llclamp(decode_priority, 0.0f, maxDecodePriority());
+	F32 decode_priority = mMaxVirtualSize;
 
 	if (mIsFetching)
 	{
+        LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - is fetching");
 		// Sets mRawDiscardLevel, mRawImage, mAuxRawImage
 		S32 fetch_discard = current_discard;
 		
@@ -2140,17 +1983,25 @@ bool LLViewerFetchedTexture::updateFetch()
 		if (finished)
 		{
 			mIsFetching = FALSE;
+            mLastFetchState = -1;
+            setDebugText("");
 			mLastPacketTimer.reset();
 		}
 		else
 		{
 			mFetchState = LLAppViewer::getTextureFetch()->getFetchState(mID, mDownloadProgress, mRequestedDownloadPriority,
 																		mFetchPriority, mFetchDeltaTime, mRequestDeltaTime, mCanUseHTTP);
+            /*if (mFetchState != mLastFetchState)
+            {
+                setDebugText(LLTextureFetch::getStateString(mFetchState));
+                mLastFetchState = mFetchState;
+            }*/
 		}
 		
 		// We may have data ready regardless of whether or not we are finished (e.g. waiting on write)
 		if (mRawImage.notNull())
 		{
+            LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - has raw image");
 			LLTexturePipelineTester* tester = (LLTexturePipelineTester*)LLMetricPerformanceTesterBasic::getTester(sTesterName);
 			if (tester)
 			{
@@ -2161,6 +2012,7 @@ bool LLViewerFetchedTexture::updateFetch()
 			if ((mRawImage->getDataSize() > 0 && mRawDiscardLevel >= 0) &&
 				(current_discard < 0 || mRawDiscardLevel < current_discard))
 			{
+                LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - data good");
 				mFullWidth = mRawImage->getWidth() << mRawDiscardLevel;
 				mFullHeight = mRawImage->getHeight() << mRawDiscardLevel;
 				setTexelsPerImage();
@@ -2197,6 +2049,7 @@ bool LLViewerFetchedTexture::updateFetch()
 			}
 			else
 			{
+                LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - data not needed");
 				// Data is ready but we don't need it
 				// (received it already while fetcher was writing to disk)
 				destroyRawImage();
@@ -2206,7 +2059,7 @@ bool LLViewerFetchedTexture::updateFetch()
 		
 		if (!mIsFetching)
 		{
-			if ((decode_priority > 0) && (mRawDiscardLevel < 0 || mRawDiscardLevel == INVALID_DISCARD_LEVEL))
+			if ((decode_priority > 0) && (mRawDiscardLevel < 0))
 			{
 				// We finished but received no data
 				if (getDiscardLevel() < 0)
@@ -2229,13 +2082,13 @@ bool LLViewerFetchedTexture::updateFetch()
 					if(current_discard >= 0)
 					{
 						mMinDiscardLevel = current_discard;
-						desired_discard = current_discard;
+						//desired_discard = current_discard;
 					}
 					else
 					{
 						S32 dis_level = getDiscardLevel();
 						mMinDiscardLevel = dis_level;
-						desired_discard = dis_level;
+						//desired_discard = dis_level;
 					}
 				}
 				destroyRawImage();
@@ -2249,12 +2102,6 @@ bool LLViewerFetchedTexture::updateFetch()
 		}
 		else
 		{
-// 			// Useful debugging code for undesired deprioritization of textures.
-// 			if (decode_priority <= 0.0f && desired_discard >= 0 && desired_discard < current_discard)
-// 			{
-// 				LL_INFOS() << "Calling updateRequestPriority() with decode_priority = 0.0f" << LL_ENDL;
-// 				calcDecodePriority();
-// 			}
 			static const F32 MAX_HOLD_TIME = 5.0f; //seconds to wait before canceling fecthing if decode_priority is 0.f.
 			if(decode_priority > 0.0f || mStopFetchingTimer.getElapsedTimeF32() > MAX_HOLD_TIME)
 			{
@@ -2264,21 +2111,27 @@ bool LLViewerFetchedTexture::updateFetch()
 		}
 	}
 
+    desired_discard = llmin(desired_discard, getMaxDiscardLevel());
+
 	bool make_request = true;	
-	if (decode_priority <= 0)
+	/*if (decode_priority <= 0)
 	{
+        LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - priority <= 0");
 		make_request = false;
 	}
 	else if(mDesiredDiscardLevel > getMaxDiscardLevel())
 	{
+        LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - desired > max");
 		make_request = false;
 	}
-	else if (mNeedsCreateTexture || mIsMissingAsset)
+	else */ if (mNeedsCreateTexture || mIsMissingAsset)
 	{
+        LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - create or missing");
 		make_request = false;
 	}
 	else if (current_discard >= 0 && current_discard <= mMinDiscardLevel)
 	{
+        LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - current < min");
 		make_request = false;
 	}
 	else if(mCachedRawImage.notNull() // can be empty
@@ -2295,6 +2148,7 @@ bool LLViewerFetchedTexture::updateFetch()
 	
 	if (make_request)
 	{
+#if 0
 		// Load the texture progressively: we try not to rush to the desired discard too fast.
 		// If the camera is not moving, we do not tweak the discard level notch by notch but go to the desired discard with larger boosted steps
 		// This mitigates the "textures stay blurry" problem when loading while not killing the texture memory while moving around
@@ -2311,18 +2165,23 @@ bool LLViewerFetchedTexture::updateFetch()
         {
 			desired_discard = llmax(desired_discard, current_discard - delta_level);
         }
+#endif
 
 		if (mIsFetching)
 		{
+            // already requested a higher resolution mip
 			if (mRequestedDiscardLevel <= desired_discard)
 			{
+                LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - requested < desired");
 				make_request = false;
 			}
 		}
 		else
 		{
+            // already at a higher resolution mip, don't discard
 			if (current_discard >= 0 && current_discard <= desired_discard)
 			{
+                LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - current <= desired");
 				make_request = false;
 			}
 		}
@@ -2330,6 +2189,7 @@ bool LLViewerFetchedTexture::updateFetch()
 	
 	if (make_request)
 	{
+        LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - make request");
 		S32 w=0, h=0, c=0;
 		if (getDiscardLevel() >= 0)
 		{
@@ -2351,6 +2211,7 @@ bool LLViewerFetchedTexture::updateFetch()
 		
 		if (fetch_request_created)
 		{
+            LL_PROFILE_ZONE_NAMED_CATEGORY_TEXTURE("vftuf - request created");
 			mHasFetcher = TRUE;
 			mIsFetching = TRUE;
 			mRequestedDiscardLevel = desired_discard;
@@ -2358,15 +2219,18 @@ bool LLViewerFetchedTexture::updateFetch()
 													   mFetchPriority, mFetchDeltaTime, mRequestDeltaTime, mCanUseHTTP);
 		}
 
-		// if createRequest() failed, we're finishing up a request for this UUID,
-		// wait for it to complete
+        // If createRequest() failed, that means one of two things:
+        // 1. We're finishing up a request for this UUID, so we
+        //    should wait for it to complete
+        // 2. We've failed a request for this UUID, so there is
+        //    no need to create another request
 	}
 	else if (mHasFetcher && !mIsFetching)
 	{
 		// Only delete requests that haven't received any network data
 		// for a while.  Note - this is the normal mechanism for
 		// deleting requests, not just a place to handle timeouts.
-		const F32 FETCH_IDLE_TIME = 5.f;
+		const F32 FETCH_IDLE_TIME = 0.1f;
 		if (mLastPacketTimer.getElapsedTimeF32() > FETCH_IDLE_TIME)
 		{
  			LL_DEBUGS("Texture") << "exceeded idle time " << FETCH_IDLE_TIME << ", deleting request: " << getID() << LL_ENDL;
@@ -2676,7 +2540,7 @@ bool LLViewerFetchedTexture::doLoadedCallbacks()
 			LL_INFOS() << "baked texture: " << mID << "clears all call backs due to inactivity." << LL_ENDL;
 			LL_INFOS() << mUrl << LL_ENDL;
 			LL_INFOS() << "current discard: " << getDiscardLevel() << " current discard for fetch: " << getCurrentDiscardLevelForFetching() <<
-				" Desired discard: " << getDesiredDiscardLevel() << "decode Pri: " << getDecodePriority() << LL_ENDL;
+				" Desired discard: " << getDesiredDiscardLevel() << "decode Pri: " << mMaxVirtualSize << LL_ENDL;
 		}
 
 		clearCallbackEntryList() ; //remove all callbacks.
@@ -2907,7 +2771,7 @@ void LLViewerFetchedTexture::forceImmediateUpdate()
 		return;
 	}
 	//if already called forceImmediateUpdate()
-	if(mInImageList && mDecodePriority == LLViewerFetchedTexture::maxDecodePriority())
+	if(mInImageList && mMaxVirtualSize == LLViewerFetchedTexture::sMaxVirtualSize)
 	{
 		return;
 	}
@@ -2976,6 +2840,7 @@ bool LLViewerFetchedTexture::needsToSaveRawImage()
 
 void LLViewerFetchedTexture::destroyRawImage()
 {	
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
 	if (mAuxRawImage.notNull() && !needsToSaveRawImage())
 	{
 		sAuxCount--;
@@ -3059,6 +2924,7 @@ void LLViewerFetchedTexture::setCachedRawImage(S32 discard_level, LLImageRaw* im
 
 void LLViewerFetchedTexture::setCachedRawImage()
 {	
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
 	if(mRawImage == mCachedRawImage)
 	{
 		return;
@@ -3134,6 +3000,7 @@ void LLViewerFetchedTexture::checkCachedRawSculptImage()
 
 void LLViewerFetchedTexture::saveRawImage() 
 {
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
 	if(mRawImage.isNull() || mRawImage == mSavedRawImage || (mSavedRawDiscardLevel >= 0 && mSavedRawDiscardLevel <= mRawDiscardLevel))
 	{
 		return;
@@ -3349,25 +3216,10 @@ void LLViewerLODTexture::processTextureStats()
 		}
 		else
 		{
-			if(isLargeImage() && !isJustBound() && mAdditionalDecodePriority < 0.3f)
-			{
-				//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)LLViewerTexture::sMinLargeImageSize);
-			}
-
-			if ((mCalculatedDiscardLevel >= 0.f) &&
-				(llabs(mMaxVirtualSize - mDiscardVirtualSize) < mMaxVirtualSize*.20f))
-			{
-				// < 20% change in virtual size = no change in desired discard
-				discard_level = mCalculatedDiscardLevel; 
-			}
-			else
-			{
-				// Calculate the required scale factor of the image using pixels per texel
-				discard_level = (F32)(log(mTexelsPerImage/mMaxVirtualSize) / log_4);
-				mDiscardVirtualSize = mMaxVirtualSize;
-				mCalculatedDiscardLevel = discard_level;
-			}
+			// Calculate the required scale factor of the image using pixels per texel
+			discard_level = (F32)(log(mTexelsPerImage/mMaxVirtualSize) / log_4);
+			mDiscardVirtualSize = mMaxVirtualSize;
+			mCalculatedDiscardLevel = discard_level;
 		}
 		if (mBoostLevel < LLGLTexture::BOOST_SCULPTED)
 		{
@@ -3407,18 +3259,6 @@ void LLViewerLODTexture::processTextureStats()
 				//needs to release texture memory urgently
 				scaleDown();
 			}
-			// Limit the amount of GL memory bound each frame
-			else if ( sBoundTextureMemory > sMaxBoundTextureMemory * texmem_middle_bound_scale &&
-				(!getBoundRecently() || mDesiredDiscardLevel >= mCachedRawDiscardLevel))
-			{
-				scaleDown();
-			}
-			// Only allow GL to have 2x the video card memory
-			else if ( sTotalTextureMemory > sMaxTotalTextureMem * texmem_middle_bound_scale &&
-				(!getBoundRecently() || mDesiredDiscardLevel >= mCachedRawDiscardLevel))
-			{
-				scaleDown();
-			}
 		}
 
 		if (isUpdateFrozen() // we are out of memory and nearing max allowed bias
@@ -4199,7 +4039,6 @@ void LLTexturePipelineTester::compareTestSessions(llofstream* os)
 	*os << llformat("%s\n", getTesterName().c_str());
 	*os << llformat("AggregateResults\n");
 
-	compareTestResults(os, "TotalFetchingTime", base_sessionp->mTotalFetchingTime, current_sessionp->mTotalFetchingTime);
 	compareTestResults(os, "TotalGrayTime", base_sessionp->mTotalGrayTime, current_sessionp->mTotalGrayTime);
 	compareTestResults(os, "TotalStablizingTime", base_sessionp->mTotalStablizingTime, current_sessionp->mTotalStablizingTime);
 	compareTestResults(os, "StartTimeLoadingSculpties", base_sessionp->mStartTimeLoadingSculpties, current_sessionp->mStartTimeLoadingSculpties);		
@@ -4259,7 +4098,6 @@ LLMetricPerformanceTesterWithSession::LLTestSession* LLTexturePipelineTester::lo
 		return NULL;
 	}
 	
-	F32 total_fetching_time = 0.f;
 	F32 total_gray_time = 0.f;
 	F32 total_stablizing_time = 0.f;
 	F32 total_loading_sculpties_time = 0.f;
@@ -4294,7 +4132,6 @@ LLMetricPerformanceTesterWithSession::LLTestSession* LLTexturePipelineTester::lo
 		F32 cur_time   = (*log)[label]["Time"].asReal();
 		if(start_time - start_fetching_time > F_ALMOST_ZERO) //fetching has paused for a while
 		{
-			sessionp->mTotalFetchingTime += total_fetching_time;
 			sessionp->mTotalGrayTime += total_gray_time;
 			sessionp->mTotalStablizingTime += total_stablizing_time;
 
@@ -4302,14 +4139,12 @@ LLMetricPerformanceTesterWithSession::LLTestSession* LLTexturePipelineTester::lo
 			sessionp->mTotalTimeLoadingSculpties += total_loading_sculpties_time;
 
 			start_fetching_time = start_time;
-			total_fetching_time = 0.0f;
 			total_gray_time = 0.f;
 			total_stablizing_time = 0.f;
 			total_loading_sculpties_time = 0.f;
 		}
 		else
 		{
-			total_fetching_time = cur_time - start_time;
 			total_gray_time = (*log)[label]["TotalGrayTime"].asReal();
 			total_stablizing_time = (*log)[label]["TotalStablizingTime"].asReal();
 
@@ -4355,7 +4190,6 @@ LLMetricPerformanceTesterWithSession::LLTestSession* LLTexturePipelineTester::lo
 		in_log = (*log).has(currentLabel);
 	}
 
-	sessionp->mTotalFetchingTime += total_fetching_time;
 	sessionp->mTotalGrayTime += total_gray_time;
 	sessionp->mTotalStablizingTime += total_stablizing_time;
 
@@ -4377,8 +4211,6 @@ LLTexturePipelineTester::LLTextureTestSession::~LLTextureTestSession()
 }
 void LLTexturePipelineTester::LLTextureTestSession::reset() 
 {
-	mTotalFetchingTime = 0.0f;
-
 	mTotalGrayTime = 0.0f;
 	mTotalStablizingTime = 0.0f;