Added FTType to texture fetch methods. Baked texture fetch now uses dynamic retry policy.

2016-05-01 19:44:06 -05:00
parent abb4b1ac7c
commit f26a5e9d62
29 changed files with 386 additions and 215 deletions
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -60,6 +60,7 @@
 #include "llstartup.h"
 #include "llsdserialize.h"
 #include "llbuffer.h"
+#include "llhttpretrypolicy.h"
 #include "hippogridmanager.h"

 #include <boost/algorithm/string/split.hpp>
@@ -74,6 +75,9 @@ LLStat LLTextureFetch::sCacheHitRate("texture_cache_hits", 128);
 LLStat LLTextureFetch::sCacheReadLatency("texture_cache_read_latency", 128);

 //////////////////////////////////////////////////////////////////////////////
+// Log scope
+static const char * const LOG_TXT = "Texture";
+
 class LLTextureFetchWorker : public LLWorkerClass
 {
 	friend class LLTextureFetch;
@@ -190,7 +194,8 @@ public:
 	LLTextureFetch & getFetcher() { return *mFetcher; }
 	
 protected:
-	LLTextureFetchWorker(LLTextureFetch* fetcher, const std::string& url, const LLUUID& id, const LLHost& host,
+	LLTextureFetchWorker(LLTextureFetch* fetcher, FTType f_type,
+						 const std::string& url, const LLUUID& id, const LLHost& host,
 						 F32 priority, S32 discard, S32 size);

 private:
@@ -256,8 +261,9 @@ private:
 	e_write_to_cache_state mWriteToCacheState;
 	LLTextureFetch* mFetcher;
 	LLPointer<LLImageFormatted> mFormattedImage;
-	LLPointer<LLImageRaw> mRawImage;
-	LLPointer<LLImageRaw> mAuxImage;
+	LLPointer<LLImageRaw>       mRawImage,
+								mAuxImage;
+	FTType mFTType;
 	LLUUID mID;
 	LLHost mHost;
 	std::string mUrl;
@@ -291,8 +297,8 @@ private:
 	BOOL mNeedsAux;
 	BOOL mHaveAllData;
 	BOOL mInLocalCache;
-	bool mCanUseHTTP ;
-	bool mCanUseNET ; //can get from asset server.
+	bool                        mCanUseHTTP,
+								mCanUseNET ; //can get from asset server.
 	S32 mHTTPFailCount;
 	S32 mRetryAttempt;
 	S32 mActiveCount;
@@ -331,7 +337,7 @@ class HTTPGetResponder : public LLHTTPClient::ResponderWithCompleted
 {
 	LOG_CLASS(HTTPGetResponder);
 public:
-	HTTPGetResponder(LLTextureFetch* fetcher, const LLUUID& id, U64 startTime, S32 requestedSize, U32 offset)
+	HTTPGetResponder( FTType f_type, LLTextureFetch* fetcher, const LLUUID& id, U64 startTime, S32 requestedSize, U32 offset)
 		: mFetcher(fetcher)
 		, mID(id)
 		, mMetricsStartTime(startTime)
@@ -340,7 +346,9 @@ public:
 		, mReplyOffset(0)
 		, mReplyLength(0)
 		, mReplyFullLength(0)
+		, mFTType(f_type)
 	{
+		mFetchRetryPolicy = new LLAdaptiveRetryPolicy(10.0,3600.0,2.0,10);
 	}
 	~HTTPGetResponder()
 	{
@@ -399,13 +407,11 @@ public:
 		
 		if (log_to_viewer_log || log_to_sim)
 		{
-			
-			U64Microseconds timeNow = LLTimer::getTotalTime();
 			mFetcher->mTextureInfo.setRequestStartTime(mID, mMetricsStartTime);
 			mFetcher->mTextureInfo.setRequestType(mID, LLTextureInfoDetails::REQUEST_TYPE_HTTP);
 			mFetcher->mTextureInfo.setRequestSize(mID, mRequestedSize);
 			mFetcher->mTextureInfo.setRequestOffset(mID, mRequestedOffset);
-			mFetcher->mTextureInfo.setRequestCompleteTimeAndLog(mID, timeNow);
+			mFetcher->mTextureInfo.setRequestCompleteTimeAndLog(mID, LLTimer::getTotalTime());
 		}

 		LL_DEBUGS("Texture") << "HTTP COMPLETE: " << mID << LL_ENDL;
@@ -417,6 +423,7 @@ public:
 			bool partial = false;
 			if (HTTP_OK <= mStatus &&  mStatus < HTTP_MULTIPLE_CHOICES)
 			{
+				mFetchRetryPolicy->onSuccess();
 				success = true;
 				if (HTTP_PARTIAL_CONTENT == mStatus) // partial information
 				{
@@ -425,8 +432,26 @@ public:
 			}
 			if (!success)
 			{
+				if(mFTType == FTT_SERVER_BAKE)
+				{
+					mFetchRetryPolicy->onFailure(getStatus(), getResponseHeaders());
+					F32 retry_after;
+					if (mFetchRetryPolicy->shouldRetry(retry_after))
+					{
+						LL_INFOS(LOG_TXT) << mID << " will retry after " << retry_after << " seconds, resetting state to LOAD_FROM_NETWORK" << LL_ENDL;
+						mFetcher->removeFromHTTPQueue(mID, 0);
+						worker->setGetStatus(mStatus, mReason);
+						worker->setState(LLTextureFetchWorker::LOAD_FROM_NETWORK);
+						worker->unlockWorkMutex();
+						return;
+					}
+				}
 				worker->setGetStatus(mStatus, mReason);
-				LL_WARNS() << "CURL GET FAILED, status:" << mStatus << " reason:" << mReason << LL_ENDL;
+				if (mFTType != FTT_MAP_TILE) // missing map tiles are normal, don't complain about them.
+				{
+					LL_WARNS(LOG_TXT) << "CURL GET FAILED, status:" << mStatus
+									  << " reason: " << mReason << LL_ENDL;
+				}
 			}
 			S32BytesImplicit data_size = worker->callbackHttpGet(mReplyOffset, mReplyLength, channels, buffer, partial, success);
 			
@@ -458,12 +483,15 @@ private:

 	LLTextureFetch* mFetcher;
 	LLUUID mID;
+	FTType mFTType;
+	LLPointer<LLHTTPRetryPolicy> mFetchRetryPolicy;
 	U64 mMetricsStartTime;
 	S32 mRequestedSize;
 	U32 mRequestedOffset;
 	U32 mReplyOffset;
 	U32 mReplyLength;
 	U32 mReplyFullLength;
+
 };

 //////////////////////////////////////////////////////////////////////////////
@@ -783,6 +811,7 @@ volatile bool LLTextureFetch::svMetricsDataBreak(true);	// Start with a data bre
 // called from MAIN THREAD

 LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
+										   FTType f_type, // Fetched image type
 										   const std::string& url, // Optional URL
 										   const LLUUID& id,	// Image UUID
 										   const LLHost& host,	// Simulator host
@@ -793,6 +822,7 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
 	  mState(INIT),
 	  mWriteToCacheState(NOT_WRITE),
 	  mFetcher(fetcher),
+	  mFTType(f_type),
 	  mID(id),
 	  mHost(host),
 	  mUrl(url),
@@ -904,7 +934,7 @@ void LLTextureFetchWorker::setupPacketData()
 		mFirstPacket = (data_size - FIRST_PACKET_SIZE) / MAX_IMG_PACKET_SIZE + 1;
 		if (FIRST_PACKET_SIZE + (mFirstPacket-1) * MAX_IMG_PACKET_SIZE != data_size)
 		{
-			LL_WARNS() << "Bad CACHED TEXTURE size: " << data_size << " removing." << LL_ENDL;
+			LL_WARNS(LOG_TXT) << "Bad CACHED TEXTURE size: " << data_size << " removing." << LL_ENDL;
 			removeFromCache();
 			resetFormattedData();
 			clearPackets();
@@ -1016,14 +1046,14 @@ bool LLTextureFetchWorker::doWork(S32 param)
 	{
 		if (mState == INIT || mState == LOAD_FROM_NETWORK/* || mState == LOAD_FROM_SIMULATOR*/) //If we've already sent out requests.. might as well continue.
 		{
-			LL_WARNS("Texture") << mID << " abort: mImagePriority < F_ALMOST_ZERO" << LL_ENDL;
+			LL_DEBUGS(LOG_TXT) << mID << " abort: mImagePriority < F_ALMOST_ZERO" << LL_ENDL;
 			return true; // abort
 		}
 	}
 	if(mState > CACHE_POST && !mCanUseNET && !mCanUseHTTP)
 	{
 		//nowhere to get data, abort.
-		LL_WARNS("Texture") << mID << " abort, nowhere to get data" << LL_ENDL;
+		LL_WARNS(LOG_TXT) << mID << " abort, nowhere to get data" << LL_ENDL;
 		return true ;
 	}
 	
@@ -1072,7 +1102,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		mCacheWriteHandle = LLTextureCache::nullHandle();
 		setState(LOAD_FROM_TEXTURE_CACHE);
 		mDesiredSize = llmax(mDesiredSize, TEXTURE_CACHE_ENTRY_SIZE); // min desired size is TEXTURE_CACHE_ENTRY_SIZE
-		LL_DEBUGS("Texture") << mID << ": Priority: " << llformat("%8.0f",mImagePriority)
+		LL_DEBUGS(LOG_TXT) << mID << ": Priority: " << llformat("%8.0f",mImagePriority)
 							 << " Desired Discard: " << mDesiredDiscard << " Desired Size: " << mDesiredSize << LL_ENDL;
 		// fall through
 	}
@@ -1104,7 +1134,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 																		  offset, size, responder);
 				mCacheReadTimer.reset();
 			}
-			else if (mUrl.empty())
+			else if ((mUrl.empty() || mFTType==FTT_SERVER_BAKE))
 			{
 				setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority); // Set priority first since Responder may change it

@@ -1145,7 +1175,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 				//
 				//This should never happen
 				//
-				LL_WARNS("Texture") << mID << " this should never happen" << LL_ENDL;
+				LL_DEBUGS(LOG_TXT) << mID << " this should never happen" << LL_ENDL;
 				return false;
 			}
 		}
@@ -1166,12 +1196,12 @@ bool LLTextureFetchWorker::doWork(S32 param)
 			mLoadedDiscard = mDesiredDiscard;
 			if (mLoadedDiscard < 0)
 			{
-				LL_WARNS("Texture") << mID << " mLoadedDiscard is " << mLoadedDiscard
+				LL_WARNS(LOG_TXT) << mID << " mLoadedDiscard is " << mLoadedDiscard
 									<< ", should be >=0" << LL_ENDL;
 			}
 			setState(DECODE_IMAGE);
 			mWriteToCacheState = NOT_WRITE ;
-			LL_DEBUGS("Texture") << mID << ": Cached. Bytes: " << mFormattedImage->getDataSize()
+			LL_DEBUGS(LOG_TXT) << mID << ": Cached. Bytes: " << mFormattedImage->getDataSize()
 								 << " Size: " << llformat("%dx%d",mFormattedImage->getWidth(),mFormattedImage->getHeight())
 								 << " Desired Discard: " << mDesiredDiscard << " Desired Size: " << mDesiredSize << LL_ENDL;
 			LLTextureFetch::sCacheHitRate.addValue(100.f);
@@ -1181,13 +1211,13 @@ bool LLTextureFetchWorker::doWork(S32 param)
 			if (mUrl.compare(0, 7, "file://") == 0)
 			{
 				// failed to load local file, we're done.
-				LL_WARNS("Texture") << mID << ": abort, failed to load local file " << mUrl << LL_ENDL;
+				LL_WARNS(LOG_TXT) << mID << ": abort, failed to load local file " << mUrl << LL_ENDL;
 				return true;
 			}
 			// need more data
 			else
 			{
-				LL_DEBUGS("Texture") << mID << ": Not in Cache" << LL_ENDL;
+				LL_DEBUGS(LOG_TXT) << mID << ": Not in Cache" << LL_ENDL;
 				setState(LOAD_FROM_NETWORK);
 			}
 			
@@ -1214,22 +1244,33 @@ bool LLTextureFetchWorker::doWork(S32 param)
 				std::string http_url = region->getHttpUrl() ;
 				if (!http_url.empty())
 				{
+					if (mFTType != FTT_DEFAULT)
+					{
+						LL_WARNS(LOG_TXT) << "trying to seek a non-default texture on the sim. Bad!" << LL_ENDL;
+					}
 					mUrl = http_url + "/?texture_id=" + mID.asString().c_str();
+					LL_DEBUGS(LOG_TXT) << "Texture URL: " << mUrl << LL_ENDL;
 					mWriteToCacheState = CAN_WRITE ; //because this texture has a fixed texture id.
 					mPerServicePtr = AIPerService::instance(AIPerService::extract_canonical_servicename(http_url));
 				}
 				else
 				{
 					mCanUseHTTP = false ;
+					LL_DEBUGS(LOG_TXT) << "Texture not available via HTTP: empty URL." << LL_ENDL;
 				}
 			}
 			else
 			{
 				// This will happen if not logged in or if a region does not have HTTP Texture enabled
 				//LL_WARNS() << "Region not found for host: " << mHost << LL_ENDL;
+				LL_DEBUGS(LOG_TXT) << "Texture not available via HTTP: no region " << mUrl << LL_ENDL;
 				mCanUseHTTP = false;
 			}
 		}
+		else if (mFTType == FTT_SERVER_BAKE)
+		{
+			mWriteToCacheState = CAN_WRITE;
+		}
 		if (!mUrl.empty() && SGHostBlackList::isBlacklisted(mUrl)){
 			mCanUseHTTP = false;
 		}
@@ -1275,19 +1316,19 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		}
 		if (processSimulatorPackets())
 		{
-			LL_DEBUGS("Texture") << mID << ": Loaded from Sim. Bytes: " << mFormattedImage->getDataSize() << LL_ENDL;
+			LL_DEBUGS(LOG_TXT) << mID << ": Loaded from Sim. Bytes: " << mFormattedImage->getDataSize() << LL_ENDL;
 			mFetcher->removeFromNetworkQueue(this, false);
 			if (mFormattedImage.isNull() || !mFormattedImage->getDataSize())
 			{
 				// processSimulatorPackets() failed
 // 				LL_WARNS() << "processSimulatorPackets() failed to load buffer" << LL_ENDL;
-				LL_WARNS("Texture") << mID << " processSimulatorPackets() failed to load buffer" << LL_ENDL;
+				LL_WARNS(LOG_TXT) << mID << " processSimulatorPackets() failed to load buffer" << LL_ENDL;
 				return true; // failed
 			}
 			setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
 			if (mLoadedDiscard < 0)
 			{
-				LL_WARNS("Texture") << mID << " mLoadedDiscard is " << mLoadedDiscard
+				LL_WARNS(LOG_TXT) << mID << " mLoadedDiscard is " << mLoadedDiscard
 									<< ", should be >=0" << LL_ENDL;
 			}
 			setState(DECODE_IMAGE);
@@ -1340,7 +1381,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 	{
 		if (! mCanUseHTTP)
 		{
-			LL_WARNS("Texture") << mID << " abort: SEND_HTTP_REQ but !mCanUseHTTP" << LL_ENDL;
+			LL_WARNS(LOG_TXT) << mID << " abort: SEND_HTTP_REQ but !mCanUseHTTP" << LL_ENDL;
 			return true ; //abort
 		}
 		S32 cur_size = 0;
@@ -1358,7 +1399,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 					setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
 					if (mLoadedDiscard < 0)
 					{
-						LL_WARNS("Texture") << mID << " mLoadedDiscard is " << mLoadedDiscard
+						LL_WARNS(LOG_TXT) << mID << " mLoadedDiscard is " << mLoadedDiscard
 											<< ", should be >=0" << LL_ENDL;
 					}
 					setState(DECODE_IMAGE);
@@ -1366,7 +1407,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 				}
 				else
 				{
-					LL_WARNS("Texture") << mID << " SEND_HTTP_REQ abort: cur_size " << cur_size << " <=0" << LL_ENDL;
+					LL_WARNS(LOG_TXT) << mID << " SEND_HTTP_REQ abort: cur_size " << cur_size << " <=0" << LL_ENDL;
 						return true ; //abort.
 				}
 			}
@@ -1404,35 +1445,33 @@ bool LLTextureFetchWorker::doWork(S32 param)
 			mRequestedSize += 1;
 		}
 		
-		if (!mUrl.empty())
-		{
-			mRequestedTimer.reset();
-			mLoaded = FALSE;
-			mGetStatus = 0;
-			mGetReason.clear();
-			LL_DEBUGS("Texture") << "HTTP GET: " << mID << " Offset: " << mRequestedOffset
-									 << " Bytes: " << mRequestedSize
-									 << LL_ENDL;
-			// Will call callbackHttpGet when curl request completes
-			AIHTTPHeaders headers("Accept", "image/x-j2c");
-			// Call LLHTTPClient::request directly instead of LLHTTPClient::getByteRange, because we want to pass a NULL AIEngine.
-			if (mRequestedOffset > 0 || mRequestedSize > 0)
-			{
-				int const range_end = mRequestedOffset + mRequestedSize - 1;
-				char const* const range_format = (range_end >= HTTP_REQUESTS_RANGE_END_MAX) ? "bytes=%d-" : "bytes=%d-%d";
-				headers.addHeader("Range", llformat(range_format, mRequestedOffset, range_end));
-			}
-			LLHTTPClient::request(mUrl, LLHTTPClient::HTTP_GET, NULL,
-				new HTTPGetResponder(mFetcher, mID, LLTimer::getTotalTime(), mRequestedSize, mRequestedOffset),
-				headers, approved/*,*/ DEBUG_CURLIO_PARAM(debug_off), keep_alive, no_does_authentication, allow_compressed_reply, NULL, 0, NULL);
-		}
-		else
+		if (mUrl.empty())
 		{
 			LL_WARNS() << "HTTP GET request failed for " << mID << LL_ENDL;
 			resetFormattedData();
 			++mHTTPFailCount;
 			return true; // failed
 		}
+		
+		mRequestedTimer.reset();
+		mLoaded = FALSE;
+		mGetStatus = 0;
+		mGetReason.clear();
+		LL_DEBUGS(LOG_TXT) << "HTTP GET: " << mID << " Offset: " << mRequestedOffset
+									 << " Bytes: " << mRequestedSize
+									 << LL_ENDL;
+		// Will call callbackHttpGet when curl request completes
+		AIHTTPHeaders headers("Accept", "image/x-j2c");
+		// Call LLHTTPClient::request directly instead of LLHTTPClient::getByteRange, because we want to pass a NULL AIEngine.
+		if (mRequestedOffset > 0 || mRequestedSize > 0)
+		{
+			int const range_end = mRequestedOffset + mRequestedSize - 1;
+			char const* const range_format = (range_end >= HTTP_REQUESTS_RANGE_END_MAX) ? "bytes=%d-" : "bytes=%d-%d";
+			headers.addHeader("Range", llformat(range_format, mRequestedOffset, range_end));
+		}
+		LLHTTPClient::request(mUrl, LLHTTPClient::HTTP_GET, NULL,
+			new HTTPGetResponder( mFTType, mFetcher, mID, LLTimer::getTotalTime(), mRequestedSize, mRequestedOffset),
+			headers, approved/*,*/ DEBUG_CURLIO_PARAM(debug_off), keep_alive, no_does_authentication, allow_compressed_reply, NULL, 0, NULL);

 		mFetcher->addToHTTPQueue(mID);
 		recordTextureStart(true);
@@ -1508,14 +1547,21 @@ bool LLTextureFetchWorker::doWork(S32 param)
 					mHTTPFailCount = max_attempts = 1; // Don't retry
 					if(mGetStatus == HTTP_NOT_FOUND)
 					{
+						if (mFTType != FTT_MAP_TILE)
+						{
+							LL_WARNS(LOG_TXT) << "Texture missing from server (404): " << mUrl << LL_ENDL;
+						}
+
 						if(mWriteToCacheState == NOT_WRITE) //map tiles
 						{
 							resetFormattedData();
 							setState(DONE);
-							//LL_INFOS("Texture") << mID << " abort: WAIT_HTTP_REQ not found" << LL_ENDL;
+							if (mFTType != FTT_MAP_TILE)
+							{
+								LL_WARNS(LOG_TXT) << mID << " abort: WAIT_HTTP_REQ not found" << LL_ENDL;
+							}
 							return true; // failed, means no map tile on the empty region.
 						}
-						LL_WARNS() << "Texture missing from server (404): " << mUrl << LL_ENDL;
 					}
 					else if (mGetStatus == HTTP_INTERNAL_ERROR_CURL_TIMEOUT || mGetStatus == HTTP_INTERNAL_ERROR_LOW_SPEED)
 					{
@@ -1576,6 +1622,10 @@ bool LLTextureFetchWorker::doWork(S32 param)

 				if (mHTTPFailCount >= max_attempts)
 				{
+					if (mFTType != FTT_SERVER_BAKE)
+					{
+						mUrl.clear();
+					}
 					// Make max_attempts attempt at decoding what data we have,
                    // then bail forever on this image
 					if (cur_size > 0 && (mHTTPFailCount < (max_attempts+1)) )
@@ -1585,8 +1635,8 @@ bool LLTextureFetchWorker::doWork(S32 param)
 						setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
 						if (mLoadedDiscard < 0)
 						{
-							LL_WARNS("Texture") << mID << " mLoadedDiscard is " << mLoadedDiscard
-												<< ", should be >=0" << LL_ENDL;
+							LL_WARNS(LOG_TXT) << mID << " mLoadedDiscard is " << mLoadedDiscard
+											  << ", should be >=0" << LL_ENDL;
 						}
 						setState(DECODE_IMAGE);
 						return false; 
@@ -1608,7 +1658,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
    						// UDP is not an option, we are dead
    						resetFormattedData();
                            setState(DONE);
-							LL_INFOS("Texture") << mID << " abort: fail harder" << LL_ENDL;
+							LL_WARNS(LOG_TXT) <<  mID << " abort: fail harder" << LL_ENDL;
    						return true; // failed
    					}
 					}
@@ -1623,7 +1673,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 			// Clear the url since we're done with the fetch
 			// Note: mUrl is used to check is fetching is required so failure to clear it will force an http fetch
 			// next time the texture is requested, even if the data have already been fetched.
-			if(mWriteToCacheState != NOT_WRITE)
+			if(mWriteToCacheState != NOT_WRITE && mFTType != FTT_SERVER_BAKE)
 			{
 				// Why do we want to keep url if NOT_WRITE - is this a proxy for map tiles?
 				mUrl.clear();
@@ -1633,7 +1683,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 			{
 				//abort.
 				setState(DONE);
-				LL_WARNS("Texture") << mID << " abort: no data received" << LL_ENDL;
+				LL_WARNS(LOG_TXT) << mID << " abort: no data received" << LL_ENDL;
 				return true;
 			}

@@ -1648,7 +1698,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 				// Get back into alignment.
 				if ((S32)mHttpReplyOffset > cur_size)
 				{
-					LL_WARNS("Texture") << "Partial HTTP response produces break in image data for texture "
+					LL_WARNS(LOG_TXT) << "Partial HTTP response produces break in image data for texture "
 										<< mID << ".  Aborting load."  << LL_ENDL;
 					setState(DONE);
 					return true;
@@ -1700,7 +1750,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 			mLoadedDiscard = mRequestedDiscard;
 			if (mLoadedDiscard < 0)
 			{
-				LL_WARNS("Texture") << mID << " mLoadedDiscard is " << mLoadedDiscard
+				LL_WARNS(LOG_TXT) << mID << " mLoadedDiscard is " << mLoadedDiscard
 									<< ", should be >=0" << LL_ENDL;
 			}
 			setState(DECODE_IMAGE);
@@ -1734,26 +1784,26 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		{
 			// We aborted, don't decode
 			setState(DONE);
-			LL_WARNS("Texture") << mID << " DECODE_IMAGE abort: desired discard " << mDesiredDiscard << "<0" << LL_ENDL;
+			LL_DEBUGS(LOG_TXT) << mID << " DECODE_IMAGE abort: desired discard " << mDesiredDiscard << "<0" << LL_ENDL;
 			return true;
 		}
 		
 		if (mFormattedImage->getDataSize() <= 0)
 		{
-			LL_WARNS() << "Decode entered with invalid mFormattedImage. ID = " << mID << LL_ENDL;
+			LL_WARNS(LOG_TXT) << "Decode entered with invalid mFormattedImage. ID = " << mID << LL_ENDL;
 			
 			//abort, don't decode
 			setState(DONE);
-			LL_WARNS("Texture") << mID << " DECODE_IMAGE abort: (mFormattedImage->getDataSize() <= 0)" << LL_ENDL;
+			LL_DEBUGS(LOG_TXT) << mID << " DECODE_IMAGE abort: (mFormattedImage->getDataSize() <= 0)" << LL_ENDL;
 			return true;
 		}
 		if (mLoadedDiscard < 0)
 		{
-			LL_WARNS() << "Decode entered with invalid mLoadedDiscard. ID = " << mID << LL_ENDL;
+			LL_WARNS(LOG_TXT) << "Decode entered with invalid mLoadedDiscard. ID = " << mID << LL_ENDL;

 			//abort, don't decode
 			setState(DONE);
-			LL_WARNS("Texture") << mID << " DECODE_IMAGE abort: mLoadedDiscard < 0" << LL_ENDL;
+			LL_DEBUGS(LOG_TXT) << mID << " DECODE_IMAGE abort: mLoadedDiscard < 0" << LL_ENDL;
 			return true;
 		}

@@ -1764,7 +1814,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		U32 image_priority = LLWorkerThread::PRIORITY_NORMAL | mWorkPriority;
 		mDecoded  = FALSE;
 		setState(DECODE_IMAGE_UPDATE);
-		LL_DEBUGS("Texture") << mID << ": Decoding. Bytes: " << mFormattedImage->getDataSize() << " Discard: " << discard
+		LL_DEBUGS(LOG_TXT) << mID << ": Decoding. Bytes: " << mFormattedImage->getDataSize() << " Discard: " << discard
 				<< " All Data: " << mHaveAllData << LL_ENDL;
 		mDecodeHandle = mFetcher->mImageDecodeThread->decodeImage(mFormattedImage, image_priority, discard, mNeedsAux,
 																  new DecodeResponder(mFetcher, mID, this));
@@ -1777,11 +1827,11 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		{
 			if (mDecodedDiscard < 0)
 			{
-				LL_WARNS("Texture") << mID << ": Failed to Decode." << LL_ENDL;
+				LL_DEBUGS(LOG_TXT) << mID << ": Failed to Decode." << LL_ENDL;
 				if (mCachedSize > 0 && !mInLocalCache && mRetryAttempt == 0)
 				{
 					// Cache file should be deleted, try again
-// 					LL_WARNS() << mID << ": Decode of cached file failed (removed), retrying" << LL_ENDL;
+ 					LL_WARNS(LOG_TXT) << mID << ": Decode of cached file failed (removed), retrying" << LL_ENDL;
 					llassert_always(mDecodeHandle == 0);
 					mFormattedImage = NULL;
 					++mRetryAttempt;
@@ -1798,7 +1848,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
 			else
 			{
 				llassert_always(mRawImage.notNull());
-				LL_DEBUGS("Texture") << mID << ": Decoded. Discard: " << mDecodedDiscard
+				LL_DEBUGS(LOG_TXT) << mID << ": Decoded. Discard: " << mDecodedDiscard
 						<< " Raw Image: " << llformat("%dx%d",mRawImage->getWidth(),mRawImage->getHeight()) << LL_ENDL;
 				setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
 				setState(WRITE_TO_CACHE);
@@ -1871,9 +1921,9 @@ bool LLTextureFetchWorker::doWork(S32 param)
 		{
 			// More data was requested, return to INIT
 			setState(INIT);
-			LL_WARNS("Texture") << mID << " more data requested, returning to INIT: " 
-								 << " mDecodedDiscard " << mDecodedDiscard << ">= 0 && mDesiredDiscard " << mDesiredDiscard
-								 << "<" << " mDecodedDiscard " << mDecodedDiscard << LL_ENDL;
+			LL_DEBUGS(LOG_TXT) << mID << " more data requested, returning to INIT: " 
+							   << " mDecodedDiscard " << mDecodedDiscard << ">= 0 && mDesiredDiscard " << mDesiredDiscard
+							   << "<" << " mDecodedDiscard " << mDecodedDiscard << LL_ENDL;
 			setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
 			return false;
 		}
@@ -2034,13 +2084,13 @@ S32 LLTextureFetchWorker::callbackHttpGet(U32 offset, U32 length,

 	if (mState != WAIT_HTTP_REQ)
 	{
-		LL_WARNS() << "callbackHttpGet for unrequested fetch worker: " << mID
+		LL_WARNS(LOG_TXT) << "callbackHttpGet for unrequested fetch worker: " << mID
 				<< " req=" << mSentRequest << " state= " << mState << LL_ENDL;
 		return data_size;
 	}
 	if (mLoaded)
 	{
-		LL_WARNS() << "Duplicate callback for " << mID.asString() << LL_ENDL;
+		LL_WARNS(LOG_TXT) << "Duplicate callback for " << mID.asString() << LL_ENDL;
 		return data_size; // ignore duplicate callback
 	}
 	if (success)
@@ -2048,7 +2098,7 @@ S32 LLTextureFetchWorker::callbackHttpGet(U32 offset, U32 length,
 		// get length of stream:
 		data_size = buffer->countAfter(channels.in(), NULL);

-		LL_DEBUGS("Texture") << "HTTP RECEIVED: " << mID.asString() << " Bytes: " << data_size << LL_ENDL;
+		LL_DEBUGS(LOG_TXT) << "HTTP RECEIVED: " << mID.asString() << " Bytes: " << data_size << LL_ENDL;
 		if (data_size > 0)
 		{
 			LLViewerStatsRecorder::instance().textureFetch(data_size);
@@ -2084,7 +2134,7 @@ S32 LLTextureFetchWorker::callbackHttpGet(U32 offset, U32 length,
 				// response body becomes the entire dataset.
 				if (data_size <= mRequestedOffset)
 				{
-					LL_WARNS("Texture") << "Fetched entire texture " << mID
+					LL_WARNS(LOG_TXT) << "Fetched entire texture " << mID
 										<< " when it was expected to be marked complete.  mImageSize:  "
 										<< mFileSize << " datasize:  " << mFormattedImage->getDataSize()
 										<< LL_ENDL;
@@ -2100,7 +2150,7 @@ S32 LLTextureFetchWorker::callbackHttpGet(U32 offset, U32 length,
 			else if (data_size > mRequestedSize)
 			{
 				// *TODO: This shouldn't be happening any more
-				LL_WARNS() << "data_size = " << data_size << " > requested: " << mRequestedSize << LL_ENDL;
+				LL_WARNS(LOG_TXT) << "data_size = " << data_size << " > requested: " << mRequestedSize << LL_ENDL;
 				mHaveAllData = TRUE;
 				llassert_always(mDecodeHandle == 0);
 				mFormattedImage = NULL; // discard any previous data we had
@@ -2188,18 +2238,18 @@ void LLTextureFetchWorker::callbackDecoded(bool success, LLImageRaw* raw, LLImag
 		mRawImage = raw;
 		mAuxImage = aux;
 		mDecodedDiscard = mFormattedImage->getDiscardLevel();
- 		LL_DEBUGS("Texture") << mID << ": Decode Finished. Discard: " << mDecodedDiscard
+ 		LL_DEBUGS(LOG_TXT) << mID << ": Decode Finished. Discard: " << mDecodedDiscard
 							 << " Raw Image: " << llformat("%dx%d",mRawImage->getWidth(),mRawImage->getHeight()) << LL_ENDL;
 	}
 	else
 	{
 		if (mFormattedImage.notNull())
 		{
-			LL_WARNS("Texture") << "DECODE FAILED: id = " << mID << ", Discard = " << (S32)mFormattedImage->getDiscardLevel() << LL_ENDL;
+			LL_WARNS(LOG_TXT) << "DECODE FAILED: id = " << mID << ", Discard = " << (S32)mFormattedImage->getDiscardLevel() << LL_ENDL;
 		}
 		else
 		{
-			LL_WARNS("Texture") << "DECODE FAILED: id = " << mID << ", mFormattedImage is Null!" << LL_ENDL;
+			LL_WARNS(LOG_TXT) << "DECODE FAILED: id = " << mID << ", mFormattedImage is Null!" << LL_ENDL;
 		}
 		removeFromCache();
 		mDecodedDiscard = -1; // Redundant, here for clarity and paranoia
@@ -2280,7 +2330,7 @@ LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* image
 	  mTotalCacheReadCount(0U),
 	  mTotalCacheWriteCount(0U)
 {
-	mTextureInfo.setUpLogging(gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog"), gSavedSettings.getBOOL("LogTextureDownloadsToSimulator"), (U32Bytes)gSavedSettings.getU32("TextureLoggingThreshold"));
+	mTextureInfo.setUpLogging(gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog"), gSavedSettings.getBOOL("LogTextureDownloadsToSimulator"), U32Bytes(gSavedSettings.getU32("TextureLoggingThreshold")));
 }

 LLTextureFetch::~LLTextureFetch()
@@ -2297,20 +2347,23 @@ LLTextureFetch::~LLTextureFetch()
 	// ~LLQueuedThread() called here
 }

-bool LLTextureFetch::createRequest(const std::string& url, const LLUUID& id, const LLHost& host, F32 priority,
+bool LLTextureFetch::createRequest(FTType f_type, const std::string& url, const LLUUID& id, const LLHost& host, F32 priority,
 								   S32 w, S32 h, S32 c, S32 desired_discard, bool needs_aux, bool can_use_http)
 {
 	if (mDebugPause)
 	{
 		return false;
 	}
-	
-	LLTextureFetchWorker* worker = getWorker(id);
+	if (f_type == FTT_SERVER_BAKE)
+	{
+		LL_DEBUGS("Avatar") << " requesting " << id << " " << w << "x" << h << " discard " << desired_discard << " type " << f_type << LL_ENDL;
+	}
+	LLTextureFetchWorker* worker = getWorker(id) ;
 	if (worker)
 	{
 		if (worker->mHost != host)
 		{
-			LL_WARNS() << "LLTextureFetch::createRequest " << id << " called with multiple hosts: "
+			LL_WARNS(LOG_TXT) << "LLTextureFetch::createRequest " << id << " called with multiple hosts: "
 					<< host << " != " << worker->mHost << LL_ENDL;
 			removeRequest(worker, true);
 			worker = NULL;
@@ -2320,9 +2373,21 @@ bool LLTextureFetch::createRequest(const std::string& url, const LLUUID& id, con

 	S32 desired_size;
 	std::string exten = gDirUtilp->getExtension(url);
-	if (!url.empty() && (!exten.empty() && LLImageBase::getCodecFromExtension(exten) != IMG_CODEC_J2C))
+	//if (f_type == FTT_SERVER_BAKE)
+    if ((f_type == FTT_SERVER_BAKE) && !url.empty() && !exten.empty() && (LLImageBase::getCodecFromExtension(exten) != IMG_CODEC_J2C))
 	{
-		LL_DEBUGS("Texture") << "full request for " << id << " exten is not J2C: " << exten << LL_ENDL;
+		// SH-4030: This case should be redundant with the following one, just
+		// breaking it out here to clarify that it's intended behavior.
+		llassert(!url.empty() && (!exten.empty() && LLImageBase::getCodecFromExtension(exten) != IMG_CODEC_J2C));
+
+		// Do full requests for baked textures to reduce interim blurring.
+		LL_DEBUGS(LOG_TXT) << "full request for " << id << " texture is FTT_SERVER_BAKE" << LL_ENDL;
+		desired_size = MAX_IMAGE_DATA_SIZE;
+		desired_discard = 0;
+	}
+	else if (!url.empty() && (!exten.empty() && LLImageBase::getCodecFromExtension(exten) != IMG_CODEC_J2C))
+	{
+		LL_DEBUGS(LOG_TXT) << "full request for " << id << " exten is not J2C: " << exten << LL_ENDL;
 		// Only do partial requests for J2C at the moment
 		//LL_INFOS() << "Merov : LLTextureFetch::createRequest(), blocking fetch on " << url << LL_ENDL; 
 		desired_size = MAX_IMAGE_DATA_SIZE;
@@ -2375,7 +2440,7 @@ bool LLTextureFetch::createRequest(const std::string& url, const LLUUID& id, con
 	}
 	else
 	{
-		worker = new LLTextureFetchWorker(this, url, id, host, priority, desired_discard, desired_size);
+		worker = new LLTextureFetchWorker(this, f_type, url, id, host, priority, desired_discard, desired_size);
 		lockQueue() ;
 		mRequestMap[id] = worker;
 		unlockQueue() ;
@@ -2387,7 +2452,8 @@ bool LLTextureFetch::createRequest(const std::string& url, const LLUUID& id, con
 		worker->unlockWorkMutex();
 	}
 	
- 	LL_DEBUGS("Texture") << "REQUESTED: " << id << " Discard: " << desired_discard << " size " << desired_size << LL_ENDL;
+ 	LL_DEBUGS(LOG_TXT) << "REQUESTED: " << id << " f_type " << fttype_to_string(f_type)
+					   << " Discard: " << desired_discard << " size " << desired_size << LL_ENDL;
 	return true;
 }

@@ -2706,10 +2772,10 @@ void LLTextureFetch::startThread()
 // Threads:  Ttf
 void LLTextureFetch::endThread()
 {
-	LL_INFOS("Texture") << "CacheReads:  " << mTotalCacheReadCount
-						<< ", CacheWrites:  " << mTotalCacheWriteCount
-						<< ", TotalHTTPReq:  " << getTotalNumHTTPRequests()
-						<< LL_ENDL;
+	LL_INFOS(LOG_TXT) << "CacheReads:  " << mTotalCacheReadCount
+					  << ", CacheWrites:  " << mTotalCacheWriteCount
+					  << ", TotalHTTPReq:  " << getTotalNumHTTPRequests()
+					  << LL_ENDL;
 }

 // Threads:  Ttf
@@ -2734,7 +2800,7 @@ void LLTextureFetch::threadedUpdate()
 		S32 q = mCurlGetRequest->getQueued();
 		if (q > 0)
 		{
-			LL_INFOS() << "Queued gets: " << q << LL_ENDL;
+			LL_INFOS(LOG_TXT) << "Queued gets: " << q << LL_ENDL;
 			info_timer.reset();
 		}
 	}
@@ -2786,7 +2852,7 @@ void LLTextureFetch::sendRequestListToSimulators()
 			(req->mState != LLTextureFetchWorker::LOAD_FROM_SIMULATOR))
 		{
 			// We already received our URL, remove from the queue
-			LL_WARNS() << "Worker: " << req->mID << " in mNetworkQueue but in wrong state: " << req->mState << LL_ENDL;
+				LL_WARNS(LOG_TXT) << "Worker: " << req->mID << " in mNetworkQueue but in wrong state: " << req->mState << LL_ENDL;
 			mNetworkQueue.erase(curiter);
 			continue;
 		}
@@ -3199,25 +3265,25 @@ S32 LLTextureFetch::getFetchState(const LLUUID& id, F32& data_progress_p, F32& r

 void LLTextureFetch::dump()
 {
-	LL_INFOS() << "LLTextureFetch REQUESTS:" << LL_ENDL;
+	LL_INFOS(LOG_TXT) << "LLTextureFetch REQUESTS:" << LL_ENDL;
 	for (request_queue_t::iterator iter = mRequestQueue.begin();
 		 iter != mRequestQueue.end(); ++iter)
 	{
 		LLQueuedThread::QueuedRequest* qreq = *iter;
 		LLWorkerThread::WorkRequest* wreq = (LLWorkerThread::WorkRequest*)qreq;
 		LLTextureFetchWorker* worker = (LLTextureFetchWorker*)wreq->getWorkerClass();
-		LL_INFOS() << " ID: " << worker->mID
+		LL_INFOS(LOG_TXT) << " ID: " << worker->mID
 				<< " PRI: " << llformat("0x%08x",wreq->getPriority())
 				<< " STATE: " << worker->sStateDescs[worker->mState]
 				<< LL_ENDL;
 	}

-	LL_INFOS() << "LLTextureFetch ACTIVE_HTTP:" << LL_ENDL;
+	LL_INFOS(LOG_TXT) << "LLTextureFetch ACTIVE_HTTP:" << LL_ENDL;
 	for (queue_t::const_iterator iter(mHTTPTextureQueue.begin());
 		 mHTTPTextureQueue.end() != iter;
 		 ++iter)
 	{
-		LL_INFOS() << " ID: " << (*iter) << LL_ENDL;
+		LL_INFOS(LOG_TXT) << " ID: " << (*iter) << LL_ENDL;
 	}
 }