summaryrefslogtreecommitdiff
path: root/indra/newview/lltexturefetch.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'indra/newview/lltexturefetch.cpp')
-rw-r--r--indra/newview/lltexturefetch.cpp288
1 files changed, 132 insertions, 156 deletions
diff --git a/indra/newview/lltexturefetch.cpp b/indra/newview/lltexturefetch.cpp
index 110aa61999..cc187a1f98 100644
--- a/indra/newview/lltexturefetch.cpp
+++ b/indra/newview/lltexturefetch.cpp
@@ -29,6 +29,7 @@
#include <iostream>
#include <map>
#include <algorithm>
+#include <atomic>
#include "lltexturefetch.h"
@@ -392,7 +393,7 @@ public:
// Threads: Ttc
void callbackCacheRead(bool success, LLImageFormatted* image,
- S32 imagesize, BOOL islocal);
+ S32 imagesize, bool islocal);
// Threads: Ttc
void callbackCacheWrite(bool success);
@@ -467,14 +468,6 @@ private:
// Locks: Mw (ctor invokes without lock)
void setDesiredDiscard(S32 discard, S32 size);
- // Threads: T*
- // Locks: Mw
- bool insertPacket(S32 index, U8* data, S32 size);
-
- // Locks: Mw
- void clearPackets();
-
-
// Locks: Mw
void removeFromCache();
@@ -545,7 +538,6 @@ private:
F32 mImagePriority; // should map to max virtual size
F32 mRequestedPriority;
S32 mDesiredDiscard;
- S32 mSimRequestedDiscard;
S32 mRequestedDiscard;
S32 mLoadedDiscard;
S32 mDecodedDiscard;
@@ -571,13 +563,13 @@ private:
mCachedSize;
e_request_state mSentRequest;
handle_t mDecodeHandle;
- BOOL mLoaded;
- BOOL mDecoded;
- BOOL mWritten;
- BOOL mNeedsAux;
- BOOL mHaveAllData;
- BOOL mInLocalCache;
- BOOL mInCache;
+ bool mLoaded;
+ bool mDecoded;
+ bool mWritten;
+ bool mNeedsAux;
+ bool mHaveAllData;
+ bool mInLocalCache;
+ bool mInCache;
bool mCanUseHTTP;
S32 mRetryAttempt;
S32 mActiveCount;
@@ -592,21 +584,6 @@ private:
// Work Data
LLMutex mWorkMutex;
- struct PacketData
- {
- PacketData(U8* data, S32 size)
- : mData(data), mSize(size)
- {}
- ~PacketData() { clearData(); }
- void clearData() { delete[] mData; mData = NULL; }
-
- U8* mData;
- U32 mSize;
- };
- std::vector<PacketData*> mPackets;
- S32 mFirstPacket;
- S32 mLastPacket;
- U16 mTotalPackets;
U8 mImageCodec;
LLViewerAssetStats::duration_t mMetricsStartTime;
@@ -893,7 +870,6 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
mImagePriority(priority),
mRequestedPriority(0.f),
mDesiredDiscard(-1),
- mSimRequestedDiscard(-1),
mRequestedDiscard(-1),
mLoadedDiscard(-1),
mDecodedDiscard(-1),
@@ -909,22 +885,19 @@ LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
mFileSize(0),
mSkippedStatesTime(0),
mCachedSize(0),
- mLoaded(FALSE),
+ mLoaded(false),
mSentRequest(UNSENT),
mDecodeHandle(0),
- mDecoded(FALSE),
- mWritten(FALSE),
- mNeedsAux(FALSE),
- mHaveAllData(FALSE),
- mInLocalCache(FALSE),
- mInCache(FALSE),
+ mDecoded(false),
+ mWritten(false),
+ mNeedsAux(false),
+ mHaveAllData(false),
+ mInLocalCache(false),
+ mInCache(false),
mCanUseHTTP(true),
mRetryAttempt(0),
mActiveCount(0),
mWorkMutex(),
- mFirstPacket(0),
- mLastPacket(-1),
- mTotalPackets(0),
mImageCodec(IMG_CODEC_INVALID),
mMetricsStartTime(0),
mHttpHandle(LLCORE_HTTP_HANDLE_INVALID),
@@ -980,7 +953,6 @@ LLTextureFetchWorker::~LLTextureFetchWorker()
mFetcher->mTextureCache->writeComplete(mCacheWriteHandle, true);
}
mFormattedImage = NULL;
- clearPackets();
if (mHttpBufferArray)
{
mHttpBufferArray->release();
@@ -992,16 +964,6 @@ LLTextureFetchWorker::~LLTextureFetchWorker()
mFetcher->updateStateStats(mCacheReadCount, mCacheWriteCount, mResourceWaitCount);
}
-// Locks: Mw
-void LLTextureFetchWorker::clearPackets()
-{
- for_each(mPackets.begin(), mPackets.end(), DeletePointer());
- mPackets.clear();
- mTotalPackets = 0;
- mLastPacket = -1;
- mFirstPacket = 0;
-}
-
// Locks: Mw (ctor invokes without lock)
void LLTextureFetchWorker::setDesiredDiscard(S32 discard, S32 size)
{
@@ -1054,7 +1016,7 @@ void LLTextureFetchWorker::resetFormattedData()
}
mHttpReplySize = 0;
mHttpReplyOffset = 0;
- mHaveAllData = FALSE;
+ mHaveAllData = false;
}
F32 LLTextureFetchWorker::getImagePriority() const
@@ -1152,10 +1114,10 @@ bool LLTextureFetchWorker::doWork(S32 param)
mRequestedOffset = 0;
mFileSize = 0;
mCachedSize = 0;
- mLoaded = FALSE;
+ mLoaded = false;
mSentRequest = UNSENT;
- mDecoded = FALSE;
- mWritten = FALSE;
+ mDecoded = false;
+ mWritten = false;
if (mHttpBufferArray)
{
mHttpBufferArray->release();
@@ -1163,12 +1125,11 @@ bool LLTextureFetchWorker::doWork(S32 param)
}
mHttpReplySize = 0;
mHttpReplyOffset = 0;
- mHaveAllData = FALSE;
- clearPackets(); // TODO: Shouldn't be necessary
+ mHaveAllData = false;
mCacheReadHandle = LLTextureCache::nullHandle();
mCacheWriteHandle = LLTextureCache::nullHandle();
setState(LOAD_FROM_TEXTURE_CACHE);
- mInCache = FALSE;
+ mInCache = false;
mDesiredSize = llmax(mDesiredSize, TEXTURE_CACHE_ENTRY_SIZE); // min desired size is TEXTURE_CACHE_ENTRY_SIZE
LL_DEBUGS(LOG_TXT) << mID << ": Priority: " << llformat("%8.0f",mImagePriority)
<< " Desired Discard: " << mDesiredDiscard << " Desired Size: " << mDesiredSize << LL_ENDL;
@@ -1190,7 +1151,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
// return false;
}
mFileSize = 0;
- mLoaded = FALSE;
+ mLoaded = false;
add(LLTextureFetch::sCacheAttempt, 1.0);
@@ -1264,7 +1225,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
<< ", should be >=0" << LL_ENDL;
}
setState(DECODE_IMAGE);
- mInCache = TRUE;
+ mInCache = true;
mWriteToCacheState = NOT_WRITE ;
LL_DEBUGS(LOG_TXT) << mID << ": Cached. Bytes: " << mFormattedImage->getDataSize()
<< " Size: " << llformat("%dx%d",mFormattedImage->getWidth(),mFormattedImage->getHeight())
@@ -1476,7 +1437,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
}
mRequestedDeltaTimer.reset();
- mLoaded = FALSE;
+ mLoaded = false;
mGetStatus = LLCore::HttpStatus();
mGetReason.clear();
LL_DEBUGS(LOG_TXT) << "HTTP GET: " << mID << " Offset: " << mRequestedOffset
@@ -1543,18 +1504,13 @@ bool LLTextureFetchWorker::doWork(S32 param)
{
if (http_not_found == mGetStatus)
{
- if (mFTType != FTT_MAP_TILE)
- {
- LL_WARNS(LOG_TXT) << "Texture missing from server (404): " << mUrl << LL_ENDL;
- }
-
if(mWriteToCacheState == NOT_WRITE) //map tiles or server bakes
{
setState(DONE);
releaseHttpSemaphore();
if (mFTType != FTT_MAP_TILE)
{
- LL_WARNS(LOG_TXT) << mID << " abort: WAIT_HTTP_REQ not found" << LL_ENDL;
+ LL_WARNS(LOG_TXT) << mID << "NOT_WRITE texture missing from server (404), abort: " << mUrl << LL_ENDL;
}
return true;
}
@@ -1564,6 +1520,10 @@ bool LLTextureFetchWorker::doWork(S32 param)
LLViewerRegion* region = getRegion();
if (!region || mLastRegionId != region->getRegionID())
{
+ if (mFTType != FTT_MAP_TILE)
+ {
+ LL_INFOS(LOG_TXT) << "Texture missing from server (404), retrying: " << mUrl << " mRetryAttempt " << mRetryAttempt << LL_ENDL;
+ }
// cap failure? try on new region.
mUrl.clear();
++mRetryAttempt;
@@ -1572,6 +1532,11 @@ bool LLTextureFetchWorker::doWork(S32 param)
return false;
}
}
+
+ if (mFTType != FTT_MAP_TILE)
+ {
+ LL_WARNS(LOG_TXT) << "Texture missing from server (404): " << mUrl << LL_ENDL;
+ }
}
else if (http_service_unavail == mGetStatus)
{
@@ -1593,7 +1558,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
else if (http_not_sat == mGetStatus)
{
// Allowed, we'll accept whatever data we have as complete.
- mHaveAllData = TRUE;
+ mHaveAllData = true;
}
else
{
@@ -1655,7 +1620,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
return true;
}
- S32 append_size(mHttpBufferArray->size());
+ S32 append_size(static_cast<S32>(mHttpBufferArray->size()));
S32 total_size(cur_size + append_size);
S32 src_offset(0);
llassert_always(append_size == mRequestedSize);
@@ -1664,7 +1629,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
// In case of a partial response, our offset may
// not be trivially contiguous with the data we have.
// Get back into alignment.
- if ( (mHttpReplyOffset > cur_size) || (cur_size > mHttpReplyOffset + append_size))
+ if ( ((S32)mHttpReplyOffset > cur_size) || (cur_size > (S32)mHttpReplyOffset + append_size))
{
LL_WARNS(LOG_TXT) << "Partial HTTP response produces break in image data for texture "
<< mID << ". Aborting load." << LL_ENDL;
@@ -1700,6 +1665,8 @@ bool LLTextureFetchWorker::doWork(S32 param)
}
}
+ LLImageDataLock lock(mFormattedImage);
+
if (mHaveAllData) //the image file is fully loaded.
{
mFileSize = total_size;
@@ -1795,8 +1762,11 @@ bool LLTextureFetchWorker::doWork(S32 param)
mRawImage = NULL;
mAuxImage = NULL;
llassert_always(mFormattedImage.notNull());
- S32 discard = mHaveAllData ? 0 : mLoadedDiscard;
- mDecoded = FALSE;
+
+ // if we have the entire image data (and the image is not J2C), decode the full res image
+ // DO NOT decode a higher res j2c than was requested. This is a waste of time and memory.
+ S32 discard = mHaveAllData && mFormattedImage->getCodec() != IMG_CODEC_J2C ? 0 : mLoadedDiscard;
+ mDecoded = false;
setState(DECODE_IMAGE_UPDATE);
LL_DEBUGS(LOG_TXT) << mID << ": Decoding. Bytes: " << mFormattedImage->getDataSize() << " Discard: " << discard
<< " All Data: " << mHaveAllData << LL_ENDL;
@@ -1871,6 +1841,9 @@ bool LLTextureFetchWorker::doWork(S32 param)
//return false;
return doWork(param);
}
+
+ LLImageDataSharedLock lock(mFormattedImage);
+
S32 datasize = mFormattedImage->getDataSize();
if(mFileSize < datasize)//This could happen when http fetching and sim fetching mixed.
{
@@ -1884,7 +1857,7 @@ bool LLTextureFetchWorker::doWork(S32 param)
}
}
llassert_always(datasize);
- mWritten = FALSE;
+ mWritten = false;
setState(WAIT_ON_WRITE);
++mCacheWriteCount;
CacheWriteResponder* responder = new CacheWriteResponder(mFetcher, mID);
@@ -2123,7 +2096,7 @@ bool LLTextureFetchWorker::deleteOK()
// Allow any pending reads or writes to complete
if (mCacheReadHandle != LLTextureCache::nullHandle())
{
- if (mFetcher->mTextureCache->readComplete(mCacheReadHandle, true))
+ if (!mFetcher->mTextureCache || mFetcher->mTextureCache->readComplete(mCacheReadHandle, true))
{
mCacheReadHandle = LLTextureCache::nullHandle();
}
@@ -2134,7 +2107,7 @@ bool LLTextureFetchWorker::deleteOK()
}
if (mCacheWriteHandle != LLTextureCache::nullHandle())
{
- if (mFetcher->mTextureCache->writeComplete(mCacheWriteHandle))
+ if (!mFetcher->mTextureCache || mFetcher->mTextureCache->writeComplete(mCacheWriteHandle))
{
mCacheWriteHandle = LLTextureCache::nullHandle();
}
@@ -2188,7 +2161,7 @@ S32 LLTextureFetchWorker::callbackHttpGet(LLCore::HttpResponse * response,
{
// get length of stream:
LLCore::BufferArray * body(response->getBody());
- data_size = body ? body->size() : 0;
+ data_size = body ? static_cast<S32>(body->size()) : 0;
LL_DEBUGS(LOG_TXT) << "HTTP RECEIVED: " << mID.asString() << " Bytes: " << data_size << LL_ENDL;
if (data_size > 0)
@@ -2234,19 +2207,19 @@ S32 LLTextureFetchWorker::callbackHttpGet(LLCore::HttpResponse * response,
<< mFileSize << " datasize: " << mFormattedImage->getDataSize()
<< LL_ENDL;
}
- mHaveAllData = TRUE;
+ mHaveAllData = true;
llassert_always(mDecodeHandle == 0);
mFormattedImage = NULL; // discard any previous data we had
}
else if (data_size < mRequestedSize)
{
- mHaveAllData = TRUE;
+ mHaveAllData = true;
}
else if (data_size > mRequestedSize)
{
// *TODO: This shouldn't be happening any more (REALLY don't expect this anymore)
LL_WARNS(LOG_TXT) << "data_size = " << data_size << " > requested: " << mRequestedSize << LL_ENDL;
- mHaveAllData = TRUE;
+ mHaveAllData = true;
llassert_always(mDecodeHandle == 0);
mFormattedImage = NULL; // discard any previous data we had
}
@@ -2255,7 +2228,7 @@ S32 LLTextureFetchWorker::callbackHttpGet(LLCore::HttpResponse * response,
{
// We requested data but received none (and no error),
// so presumably we have all of it
- mHaveAllData = TRUE;
+ mHaveAllData = true;
}
mRequestedSize = data_size;
@@ -2271,7 +2244,7 @@ S32 LLTextureFetchWorker::callbackHttpGet(LLCore::HttpResponse * response,
mRequestedSize = -1; // error
}
- mLoaded = TRUE;
+ mLoaded = true;
return data_size ;
}
@@ -2280,7 +2253,7 @@ S32 LLTextureFetchWorker::callbackHttpGet(LLCore::HttpResponse * response,
// Threads: Ttc
void LLTextureFetchWorker::callbackCacheRead(bool success, LLImageFormatted* image,
- S32 imagesize, BOOL islocal)
+ S32 imagesize, bool islocal)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
LLMutexLock lock(&mWorkMutex); // +Mw
@@ -2298,10 +2271,10 @@ void LLTextureFetchWorker::callbackCacheRead(bool success, LLImageFormatted* ima
mInLocalCache = islocal;
if (mFileSize != 0 && mFormattedImage->getDataSize() >= mFileSize)
{
- mHaveAllData = TRUE;
+ mHaveAllData = true;
}
}
- mLoaded = TRUE;
+ mLoaded = true;
} // -Mw
// Threads: Ttc
@@ -2313,7 +2286,7 @@ void LLTextureFetchWorker::callbackCacheWrite(bool success)
// LL_WARNS(LOG_TXT) << "Write callback for " << mID << " with state = " << mState << LL_ENDL;
return;
}
- mWritten = TRUE;
+ mWritten = true;
} // -Mw
//////////////////////////////////////////////////////////////////////////////
@@ -2349,6 +2322,10 @@ void LLTextureFetchWorker::callbackDecoded(bool success, const std::string &erro
mRawImage = raw;
mAuxImage = aux;
mDecodedDiscard = mFormattedImage->getDiscardLevel();
+ if (mDecodedDiscard < mDesiredDiscard)
+ {
+ LL_WARNS_ONCE(LOG_TXT) << "Decoded higher resolution than requested" << LL_ENDL;
+ }
LL_DEBUGS(LOG_TXT) << mID << ": Decode Finished. Discard: " << mDecodedDiscard
<< " Raw Image: " << llformat("%dx%d",mRawImage->getWidth(),mRawImage->getHeight()) << LL_ENDL;
}
@@ -2358,7 +2335,7 @@ void LLTextureFetchWorker::callbackDecoded(bool success, const std::string &erro
removeFromCache();
mDecodedDiscard = -1; // Redundant, here for clarity and paranoia
}
- mDecoded = TRUE;
+ mDecoded = true;
// LL_INFOS(LOG_TXT) << mID << " : DECODE COMPLETE " << LL_ENDL;
} // -Mw
@@ -2435,9 +2412,7 @@ std::string LLTextureFetch::getStateString(S32 state)
LLTextureFetch::LLTextureFetch(LLTextureCache* cache, bool threaded, bool qa_mode)
: LLWorkerThread("TextureFetch", threaded, true),
mDebugCount(0),
- mDebugPause(FALSE),
- mPacketCount(0),
- mBadPacketCount(0),
+ mDebugPause(false),
mQueueMutex(),
mNetworkQueueMutex(),
mTextureCache(cache),
@@ -2509,29 +2484,28 @@ LLTextureFetch::~LLTextureFetch()
}
S32 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, S32& worker_discard)
+ S32 w, S32 h, S32 c, S32 desired_discard, bool needs_aux, bool can_use_http)
{
LL_PROFILE_ZONE_SCOPED;
- worker_discard = -1;
if (mDebugPause)
{
- return FETCH_REQUEST_CREATION_FAILED;
+ return CREATE_REQUEST_ERROR_DEFAULT;
}
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) ;
+ LLTextureFetchWorker* worker = getWorker(id);
if (worker)
{
if (worker->mHost != host)
{
LL_WARNS(LOG_TXT) << "LLTextureFetch::createRequest " << id << " called with multiple hosts: "
- << host << " != " << worker->mHost << LL_ENDL;
+ << host << " != " << worker->mHost << LL_ENDL;
removeRequest(worker, true);
worker = NULL;
- return FETCH_REQUEST_ABORTED;
+ return CREATE_REQUEST_ERROR_MHOSTS;
}
}
@@ -2564,7 +2538,7 @@ S32 LLTextureFetch::createRequest(FTType f_type, const std::string& url, const L
// we really do get it.)
desired_size = MAX_IMAGE_DATA_SIZE;
}
- else if (w*h*c > 0)
+ else if (w * h * c > 0)
{
// If the requester knows the dimensions of the image,
// this will calculate how much data we need without having to parse the header
@@ -2584,14 +2558,13 @@ S32 LLTextureFetch::createRequest(FTType f_type, const std::string& url, const L
{
if (worker->wasAborted())
{
- return FETCH_REQUEST_ABORTED; // need to wait for previous aborted request to complete
+ return CREATE_REQUEST_ERROR_ABORTED; // need to wait for previous aborted request to complete
}
- worker_discard = desired_discard;
worker->lockWorkMutex(); // +Mw
if (worker->mState == LLTextureFetchWorker::DONE && worker->mDesiredSize == llmax(desired_size, TEXTURE_CACHE_ENTRY_SIZE) && worker->mDesiredDiscard == desired_discard) {
worker->unlockWorkMutex(); // -Mw
- return FETCH_REQUEST_EXISTS; // similar request has failed or is in a transitional state
+ return CREATE_REQUEST_ERROR_TRANSITION; // similar request has finished, failed or is in a transitional state
}
worker->mActiveCount++;
worker->mNeedsAux = needs_aux;
@@ -2623,15 +2596,15 @@ S32 LLTextureFetch::createRequest(FTType f_type, const std::string& url, const L
worker->lockWorkMutex(); // +Mw
worker->mActiveCount++;
worker->mNeedsAux = needs_aux;
- worker->setCanUseHTTP(can_use_http) ;
+ worker->setCanUseHTTP(can_use_http);
worker->unlockWorkMutex(); // -Mw
- worker_discard = desired_discard;
}
LL_DEBUGS(LOG_TXT) << "REQUESTED: " << id << " f_type " << fttype_to_string(f_type)
- << " Discard: " << desired_discard << " size " << desired_size << LL_ENDL;
- return FETCH_REQUEST_OK;
+ << " Discard: " << desired_discard << " size " << desired_size << LL_ENDL;
+ return desired_discard;
}
+
// Threads: T*
//
// protected
@@ -2774,7 +2747,7 @@ LLTextureFetchWorker* LLTextureFetch::getWorker(const LLUUID& id)
// Threads: T*
-bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level,
+bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level, S32& worker_state,
LLPointer<LLImageRaw>& raw, LLPointer<LLImageRaw>& aux,
LLCore::HttpStatus& last_http_get_status)
{
@@ -2783,6 +2756,7 @@ bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level,
LLTextureFetchWorker* worker = getWorker(id);
if (worker)
{
+ worker_state = worker->mState;
if (worker->wasAborted())
{
res = true;
@@ -2861,6 +2835,7 @@ bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level,
}
else
{
+ worker_state = 0;
res = true;
}
return res;
@@ -2870,7 +2845,7 @@ bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level,
bool LLTextureFetch::updateRequestPriority(const LLUUID& id, F32 priority)
{
LL_PROFILE_ZONE_SCOPED;
- mRequestQueue.tryPost([=]()
+ mRequestQueue.tryPost([=, this]()
{
LLTextureFetchWorker* worker = getWorker(id);
if (worker)
@@ -3064,43 +3039,6 @@ void LLTextureFetch::threadedUpdate()
#endif
}
-//////////////////////////////////////////////////////////////////////////////
-
-// Threads: T*
-// Locks: Mw
-bool LLTextureFetchWorker::insertPacket(S32 index, U8* data, S32 size)
-{
- LL_PROFILE_ZONE_SCOPED;
- mRequestedDeltaTimer.reset();
- if (index >= mTotalPackets)
- {
-// LL_WARNS(LOG_TXT) << "Received Image Packet " << index << " > max: " << mTotalPackets << " for image: " << mID << LL_ENDL;
- return false;
- }
- if (index > 0 && index < mTotalPackets-1 && size != MAX_IMG_PACKET_SIZE)
- {
-// LL_WARNS(LOG_TXT) << "Received bad sized packet: " << index << ", " << size << " != " << MAX_IMG_PACKET_SIZE << " for image: " << mID << LL_ENDL;
- return false;
- }
-
- if (index >= (S32)mPackets.size())
- {
- mPackets.resize(index+1, (PacketData*)NULL); // initializes v to NULL pointers
- }
- else if (mPackets[index] != NULL)
- {
-// LL_WARNS(LOG_TXT) << "Received duplicate packet: " << index << " for image: " << mID << LL_ENDL;
- return false;
- }
-
- mPackets[index] = new PacketData(data, size);
- while (mLastPacket+1 < (S32)mPackets.size() && mPackets[mLastPacket+1] != NULL)
- {
- ++mLastPacket;
- }
- return true;
-}
-
void LLTextureFetchWorker::setState(e_state new_state)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
@@ -3147,9 +3085,9 @@ LLViewerRegion* LLTextureFetchWorker::getRegion()
//////////////////////////////////////////////////////////////////////////////
// Threads: T*
-BOOL LLTextureFetch::isFromLocalCache(const LLUUID& id)
+bool LLTextureFetch::isFromLocalCache(const LLUUID& id)
{
- BOOL from_cache = FALSE ;
+ bool from_cache = false ;
LLTextureFetchWorker* worker = getWorker(id);
if (worker)
@@ -3208,7 +3146,7 @@ S32 LLTextureFetch::getFetchState(const LLUUID& id, F32& data_progress_p, F32& r
{
requested_priority = worker->mImagePriority;
}
- fetch_priority = worker->getImagePriority();
+ fetch_priority = (U32)worker->getImagePriority();
can_use_http = worker->getCanUseHTTP() ;
worker->unlockWorkMutex(); // -Mw
}
@@ -3220,6 +3158,43 @@ S32 LLTextureFetch::getFetchState(const LLUUID& id, F32& data_progress_p, F32& r
return state;
}
+// Threads: T*
+S32 LLTextureFetch::getLastFetchState(const LLUUID& id, S32& requested_discard, S32& decoded_discard, bool& decoded)
+{
+ LL_PROFILE_ZONE_SCOPED;
+ S32 state = LLTextureFetchWorker::INVALID;
+
+ LLTextureFetchWorker* worker = getWorker(id);
+ if (worker) // Don't check haveWork, intent is to get whatever is in the worker
+ {
+ worker->lockWorkMutex(); // +Mw
+ state = worker->mState;
+ requested_discard = worker->mDesiredDiscard;
+ decoded_discard = worker->mDecodedDiscard;
+ decoded = worker->mDecoded;
+ worker->unlockWorkMutex(); // -Mw
+ }
+ return state;
+}
+
+// Threads: T*
+S32 LLTextureFetch::getLastRawImage(const LLUUID& id,
+ LLPointer<LLImageRaw>& raw, LLPointer<LLImageRaw>& aux)
+{
+ LL_PROFILE_ZONE_SCOPED;
+ S32 decoded_discard = -1;
+ LLTextureFetchWorker* worker = getWorker(id);
+ if (worker && !worker->haveWork() && worker->mDecodedDiscard >= 0)
+ {
+ worker->lockWorkMutex(); // +Mw
+ raw = worker->mRawImage;
+ aux = worker->mAuxImage;
+ decoded_discard = worker->mDecodedDiscard;
+ worker->unlockWorkMutex(); // -Mw
+ }
+ return decoded_discard;
+}
+
void LLTextureFetch::dump()
{
LL_INFOS(LOG_TXT) << "LLTextureFetch ACTIVE_HTTP:" << LL_ENDL;
@@ -3403,7 +3378,7 @@ void LLTextureFetch::cancelHttpWaiters()
int LLTextureFetch::getHttpWaitersCount()
{
mNetworkQueueMutex.lock(); // +Mfnq
- int ret(mHttpWaitResource.size());
+ int ret(static_cast<int>(mHttpWaitResource.size()));
mNetworkQueueMutex.unlock(); // -Mfnq
return ret;
}
@@ -3598,29 +3573,30 @@ TFReqSendMetrics::doWork(LLTextureFetch * fetcher)
//if (! gViewerAssetStatsThread1)
// return true;
- static volatile bool reporting_started(false);
- static volatile S32 report_sequence(0);
+ static std::atomic<bool> reporting_started(false);
+ static std::atomic<S32> report_sequence(0);
// In mStatsSD, we have a copy we own of the LLSD representation
// of the asset stats. Add some additional fields and ship it off.
static const S32 metrics_data_version = 2;
- bool initial_report = !reporting_started;
+ bool initial_report = !reporting_started.load();
mStatsSD["session_id"] = mSessionID;
mStatsSD["agent_id"] = mAgentID;
mStatsSD["message"] = "ViewerAssetMetrics";
- mStatsSD["sequence"] = report_sequence;
+ mStatsSD["sequence"] = report_sequence.load();
mStatsSD["initial"] = initial_report;
mStatsSD["version"] = metrics_data_version;
mStatsSD["break"] = static_cast<bool>(LLTextureFetch::svMetricsDataBreak);
// Update sequence number
- if (S32_MAX == ++report_sequence)
+ if (S32_MAX == report_sequence.fetch_add(1))
{
- report_sequence = 0;
+ report_sequence.store(0);
}
- reporting_started = true;
+
+ reporting_started.store(true);
// Limit the size of the stats report if necessary.
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-27 12:05:24 +0000