开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
lltexturefetch.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：60k
源码类别：

游戏引擎

开发平台：

C++ Builder

lltexturefetch.cpp：源码内容
  1. /** 
  2.  * @file lltexturefetch.cpp
  3.  * @brief Object which fetches textures from the cache and/or network
  4.  *
  5.  * $LicenseInfo:firstyear=2000&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2000-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include <iostream>
  37. #include "llstl.h"
  39. #include "lltexturefetch.h"
  41. #include "llcurl.h"
  42. #include "lldir.h"
  43. #include "llhttpclient.h"
  44. #include "llhttpstatuscodes.h"
  45. #include "llimage.h"
  46. #include "llimagej2c.h"
  47. #include "llimageworker.h"
  48. #include "llworkerthread.h"
  49. #include "message.h"
  51. #include "llagent.h"
  52. #include "lltexturecache.h"
  53. #include "llviewercontrol.h"
  54. #include "llviewertexturelist.h"
  55. #include "llviewertexture.h"
  56. #include "llviewerregion.h"
  57. #include "llworld.h"
  59. //////////////////////////////////////////////////////////////////////////////
  60. class LLTextureFetchWorker : public LLWorkerClass
  61. {
  62. friend class LLTextureFetch;
  63. friend class HTTPGetResponder;
  65. private:
  66. class CacheReadResponder : public LLTextureCache::ReadResponder
  67. {
  68. public:
  69. CacheReadResponder(LLTextureFetch* fetcher, const LLUUID& id, LLImageFormatted* image)
  70. : mFetcher(fetcher), mID(id)
  71. {
  72. setImage(image);
  73. }
  74. virtual void completed(bool success)
  75. {
  76. LLTextureFetchWorker* worker = mFetcher->getWorker(mID);
  77. if (worker)
  78. {
  79.   worker->callbackCacheRead(success, mFormattedImage, mImageSize, mImageLocal);
  80. }
  81. }
  82. private:
  83. LLTextureFetch* mFetcher;
  84. LLUUID mID;
  85. };
  87. class CacheWriteResponder : public LLTextureCache::WriteResponder
  88. {
  89. public:
  90. CacheWriteResponder(LLTextureFetch* fetcher, const LLUUID& id)
  91. : mFetcher(fetcher), mID(id)
  92. {
  93. }
  94. virtual void completed(bool success)
  95. {
  96. LLTextureFetchWorker* worker = mFetcher->getWorker(mID);
  97. if (worker)
  98. {
  99. worker->callbackCacheWrite(success);
  100. }
  101. }
  102. private:
  103. LLTextureFetch* mFetcher;
  104. LLUUID mID;
  105. };
  107. class DecodeResponder : public LLImageDecodeThread::Responder
  108. {
  109. public:
  110. DecodeResponder(LLTextureFetch* fetcher, const LLUUID& id, LLTextureFetchWorker* worker)
  111. : mFetcher(fetcher), mID(id), mWorker(worker)
  112. {
  113. }
  114. virtual void completed(bool success, LLImageRaw* raw, LLImageRaw* aux)
  115. {
  116. LLTextureFetchWorker* worker = mFetcher->getWorker(mID);
  117. if (worker)
  118. {
  119.   worker->callbackDecoded(success, raw, aux);
  120. }
  121. }
  122. private:
  123. LLTextureFetch* mFetcher;
  124. LLUUID mID;
  125. LLTextureFetchWorker* mWorker; // debug only (may get deleted from under us, use mFetcher/mID)
  126. };
  128. struct Compare
  129. {
  130. // lhs < rhs
  131. bool operator()(const LLTextureFetchWorker* lhs, const LLTextureFetchWorker* rhs) const
  132. {
  133. // greater priority is "less"
  134. const F32 lpriority = lhs->mImagePriority;
  135. const F32 rpriority = rhs->mImagePriority;
  136. if (lpriority > rpriority) // higher priority
  137. return true;
  138. else if (lpriority < rpriority)
  139. return false;
  140. else
  141. return lhs < rhs;
  142. }
  143. };
  145. public:
  146. /*virtual*/ bool doWork(S32 param); // Called from LLWorkerThread::processRequest()
  147. /*virtual*/ void finishWork(S32 param, bool completed); // called from finishRequest() (WORK THREAD)
  148. /*virtual*/ bool deleteOK(); // called from update() (WORK THREAD)
  150. ~LLTextureFetchWorker();
  151. void relese() { --mActiveCount; }
  153. void callbackHttpGet(const LLChannelDescriptors& channels,
  154.  const LLIOPipe::buffer_ptr_t& buffer,
  155.  bool partial, bool success);
  156. void callbackCacheRead(bool success, LLImageFormatted* image,
  157.    S32 imagesize, BOOL islocal);
  158. void callbackCacheWrite(bool success);
  159. void callbackDecoded(bool success, LLImageRaw* raw, LLImageRaw* aux);
  161. void setGetStatus(U32 status, const std::string& reason)
  162. {
  163. LLMutexLock lock(&mWorkMutex);
  165. mGetStatus = status;
  166. mGetReason = reason;
  167. }
  169. protected:
  170. LLTextureFetchWorker(LLTextureFetch* fetcher, const LLUUID& id, const LLHost& host,
  171.  F32 priority, S32 discard, S32 size);
  172. LLTextureFetchWorker(LLTextureFetch* fetcher, const std::string& url, const LLUUID& id, const LLHost& host,
  173.  F32 priority, S32 discard, S32 size);
  175. private:
  176. /*virtual*/ void startWork(S32 param); // called from addWork() (MAIN THREAD)
  177. /*virtual*/ void endWork(S32 param, bool aborted); // called from doWork() (MAIN THREAD)
  179. void resetFormattedData();
  181. void setImagePriority(F32 priority);
  182. void setDesiredDiscard(S32 discard, S32 size);
  183. bool insertPacket(S32 index, U8* data, S32 size);
  184. void clearPackets();
  185. void setupPacketData();
  186. U32 calcWorkPriority();
  187. void removeFromCache();
  188. bool processSimulatorPackets();
  189. bool writeToCacheComplete();
  191. void lockWorkMutex() { mWorkMutex.lock(); }
  192. void unlockWorkMutex() { mWorkMutex.unlock(); }
  194. private:
  195. enum e_state // mState
  196. {
  197. // NOTE: Affects LLTextureBar::draw in lltextureview.cpp (debug hack)
  198. INVALID = 0,
  199. INIT,
  200. LOAD_FROM_TEXTURE_CACHE,
  201. CACHE_POST,
  202. LOAD_FROM_NETWORK,
  203. LOAD_FROM_SIMULATOR,
  204. SEND_HTTP_REQ,
  205. WAIT_HTTP_REQ,
  206. DECODE_IMAGE,
  207. DECODE_IMAGE_UPDATE,
  208. WRITE_TO_CACHE,
  209. WAIT_ON_WRITE,
  210. DONE
  211. };
  212. enum e_request_state // mSentRequest
  213. {
  214. UNSENT = 0,
  215. QUEUED = 1,
  216. SENT_SIM = 2
  217. };
  218. static const char* sStateDescs[];
  219. e_state mState;
  220. LLTextureFetch* mFetcher;
  221. LLPointer<LLImageFormatted> mFormattedImage;
  222. LLPointer<LLImageRaw> mRawImage;
  223. LLPointer<LLImageRaw> mAuxImage;
  224. LLUUID mID;
  225. LLHost mHost;
  226. std::string mUrl;
  227. U8 mType;
  228. F32 mImagePriority;
  229. U32 mWorkPriority;
  230. F32 mRequestedPriority;
  231. S32 mDesiredDiscard;
  232. S32 mSimRequestedDiscard;
  233. S32 mRequestedDiscard;
  234. S32 mLoadedDiscard;
  235. S32 mDecodedDiscard;
  236. LLFrameTimer mRequestedTimer;
  237. LLFrameTimer mFetchTimer;
  238. LLTextureCache::handle_t mCacheReadHandle;
  239. LLTextureCache::handle_t mCacheWriteHandle;
  240. U8* mBuffer;
  241. S32 mBufferSize;
  242. S32 mRequestedSize;
  243. S32 mDesiredSize;
  244. S32 mFileSize;
  245. S32 mCachedSize;
  246. BOOL mLoaded;
  247. e_request_state mSentRequest;
  248. handle_t mDecodeHandle;
  249. BOOL mDecoded;
  250. BOOL mWritten;
  251. BOOL mNeedsAux;
  252. BOOL mHaveAllData;
  253. BOOL mInLocalCache;
  254. S32 mHTTPFailCount;
  255. S32 mRetryAttempt;
  256. S32 mActiveCount;
  257. U32 mGetStatus;
  258. std::string mGetReason;
  260. // Work Data
  261. LLMutex mWorkMutex;
  262. struct PacketData
  263. {
  264. PacketData(U8* data, S32 size) { mData = data; mSize = size; }
  265. ~PacketData() { clearData(); }
  266. void clearData() { delete[] mData; mData = NULL; }
  267. U8* mData;
  268. U32 mSize;
  269. };
  270. std::vector<PacketData*> mPackets;
  271. S32 mFirstPacket;
  272. S32 mLastPacket;
  273. U16 mTotalPackets;
  274. U8 mImageCodec;
  275. };
  277. //////////////////////////////////////////////////////////////////////////////
  279. class HTTPGetResponder : public LLCurl::Responder
  280. {
  281. LOG_CLASS(HTTPGetResponder);
  282. public:
  283. HTTPGetResponder(LLTextureFetch* fetcher, const LLUUID& id, U64 startTime, S32 requestedSize, U32 offset)
  284. : mFetcher(fetcher), mID(id), mStartTime(startTime), mRequestedSize(requestedSize), mOffset(offset)
  285. {
  286. }
  287. ~HTTPGetResponder()
  288. {
  289. }
  291. virtual void completedRaw(U32 status, const std::string& reason,
  292.   const LLChannelDescriptors& channels,
  293.   const LLIOPipe::buffer_ptr_t& buffer)
  294. {
  295. if ((gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog")) || (gSavedSettings.getBOOL("LogTextureDownloadsToSimulator")))
  296. {
  297. mFetcher->mTextureInfo.setRequestStartTime(mID, mStartTime);
  298. U64 timeNow = LLTimer::getTotalTime();
  299. mFetcher->mTextureInfo.setRequestType(mID, LLTextureInfoDetails::REQUEST_TYPE_HTTP);
  300. mFetcher->mTextureInfo.setRequestSize(mID, mRequestedSize);
  301. mFetcher->mTextureInfo.setRequestOffset(mID, mOffset);
  302. mFetcher->mTextureInfo.setRequestCompleteTimeAndLog(mID, timeNow);
  303. }
  305. lldebugs << "HTTP COMPLETE: " << mID << llendl;
  306. LLTextureFetchWorker* worker = mFetcher->getWorker(mID);
  307. if (worker)
  308. {
  309. bool success = false;
  310. bool partial = false;
  311. if (HTTP_OK <= status &&  status < HTTP_MULTIPLE_CHOICES)
  312. {
  313. success = true;
  314. if (HTTP_PARTIAL_CONTENT == status) // partial information
  315. {
  316. partial = true;
  317. }
  318. }
  319. else
  320. {
  321. worker->setGetStatus(status, reason);
  322. //  llwarns << status << ": " << reason << llendl;
  323. }
  324. if (!success)
  325. {
  326. worker->setGetStatus(status, reason);
  327. //  llwarns << "CURL GET FAILED, status:" << status << " reason:" << reason << llendl;
  328. }
  329. mFetcher->removeFromHTTPQueue(mID);
  330. worker->callbackHttpGet(channels, buffer, partial, success);
  331. }
  332. else
  333. {
  334. mFetcher->removeFromHTTPQueue(mID);
  335.   llwarns << "Worker not found: " << mID << llendl;
  336. }
  337. }
  339. private:
  340. LLTextureFetch* mFetcher;
  341. LLUUID mID;
  342. U64 mStartTime;
  343. S32 mRequestedSize;
  344. U32 mOffset;
  345. };
  347. //////////////////////////////////////////////////////////////////////////////
  349. //static
  350. const char* LLTextureFetchWorker::sStateDescs[] = {
  351. "INVALID",
  352. "INIT",
  353. "LOAD_FROM_TEXTURE_CACHE",
  354. "CACHE_POST",
  355. "LOAD_FROM_NETWORK",
  356. "LOAD_FROM_SIMULATOR",
  357. "SEND_HTTP_REQ",
  358. "WAIT_HTTP_REQ",
  359. "DECODE_IMAGE",
  360. "DECODE_IMAGE_UPDATE",
  361. "WRITE_TO_CACHE",
  362. "WAIT_ON_WRITE",
  363. "DONE",
  364. };
  366. // called from MAIN THREAD
  368. LLTextureFetchWorker::LLTextureFetchWorker(LLTextureFetch* fetcher,
  369.    const std::string& url, // Optional URL
  370.    const LLUUID& id, // Image UUID
  371.    const LLHost& host, // Simulator host
  372.    F32 priority, // Priority
  373.    S32 discard, // Desired discard
  374.    S32 size) // Desired size
  375. : LLWorkerClass(fetcher, "TextureFetch"),
  376.   mState(INIT),
  377.   mFetcher(fetcher),
  378.   mID(id),
  379.   mHost(host),
  380.   mUrl(url),
  381.   mImagePriority(priority),
  382.   mWorkPriority(0),
  383.   mRequestedPriority(0.f),
  384.   mDesiredDiscard(-1),
  385.   mSimRequestedDiscard(-1),
  386.   mRequestedDiscard(-1),
  387.   mLoadedDiscard(-1),
  388.   mDecodedDiscard(-1),
  389.   mCacheReadHandle(LLTextureCache::nullHandle()),
  390.   mCacheWriteHandle(LLTextureCache::nullHandle()),
  391.   mBuffer(NULL),
  392.   mBufferSize(0),
  393.   mRequestedSize(0),
  394.   mDesiredSize(TEXTURE_CACHE_ENTRY_SIZE),
  395.   mFileSize(0),
  396.   mCachedSize(0),
  397.   mLoaded(FALSE),
  398.   mSentRequest(UNSENT),
  399.   mDecodeHandle(0),
  400.   mDecoded(FALSE),
  401.   mWritten(FALSE),
  402.   mNeedsAux(FALSE),
  403.   mHaveAllData(FALSE),
  404.   mInLocalCache(FALSE),
  405.   mHTTPFailCount(0),
  406.   mRetryAttempt(0),
  407.   mActiveCount(0),
  408.   mGetStatus(0),
  409.   mWorkMutex(NULL),
  410.   mFirstPacket(0),
  411.   mLastPacket(-1),
  412.   mTotalPackets(0),
  413.   mImageCodec(IMG_CODEC_INVALID)
  414. {
  415. calcWorkPriority();
  416. mType = host.isOk() ? LLImageBase::TYPE_AVATAR_BAKE : LLImageBase::TYPE_NORMAL;
  417. //  llinfos << "Create: " << mID << " mHost:" << host << " Discard=" << discard << llendl;
  418. if (!mFetcher->mDebugPause)
  419. {
  420. U32 work_priority = mWorkPriority | LLWorkerThread::PRIORITY_HIGH;
  421. addWork(0, work_priority );
  422. }
  423. setDesiredDiscard(discard, size);
  424. }
  426. LLTextureFetchWorker::~LLTextureFetchWorker()
  427. {
  428. //  llinfos << "Destroy: " << mID
  429. //  << " Decoded=" << mDecodedDiscard
  430. //  << " Requested=" << mRequestedDiscard
  431. //  << " Desired=" << mDesiredDiscard << llendl;
  432. llassert_always(!haveWork());
  433. lockWorkMutex();
  434. if (mCacheReadHandle != LLTextureCache::nullHandle())
  435. {
  436. mFetcher->mTextureCache->readComplete(mCacheReadHandle, true);
  437. }
  438. if (mCacheWriteHandle != LLTextureCache::nullHandle())
  439. {
  440. mFetcher->mTextureCache->writeComplete(mCacheWriteHandle, true);
  441. }
  442. mFormattedImage = NULL;
  443. clearPackets();
  444. unlockWorkMutex();
  445. mFetcher->removeFromHTTPQueue(mID);
  446. }
  448. void LLTextureFetchWorker::clearPackets()
  449. {
  450. for_each(mPackets.begin(), mPackets.end(), DeletePointer());
  451. mPackets.clear();
  452. mTotalPackets = 0;
  453. mLastPacket = -1;
  454. mFirstPacket = 0;
  455. }
  457. void LLTextureFetchWorker::setupPacketData()
  458. {
  459. S32 data_size = 0;
  460. if (mFormattedImage.notNull())
  461. {
  462. data_size = mFormattedImage->getDataSize();
  463. }
  464. if (data_size > 0)
  465. {
  466. // Only used for simulator requests
  467. mFirstPacket = (data_size - FIRST_PACKET_SIZE) / MAX_IMG_PACKET_SIZE + 1;
  468. if (FIRST_PACKET_SIZE + (mFirstPacket-1) * MAX_IMG_PACKET_SIZE != data_size)
  469. {
  470. llwarns << "Bad CACHED TEXTURE size: " << data_size << " removing." << llendl;
  471. removeFromCache();
  472. resetFormattedData();
  473. clearPackets();
  474. }
  475. else if (mFileSize > 0)
  476. {
  477. mLastPacket = mFirstPacket-1;
  478. mTotalPackets = (mFileSize - FIRST_PACKET_SIZE + MAX_IMG_PACKET_SIZE-1) / MAX_IMG_PACKET_SIZE + 1;
  479. }
  480. else
  481. {
  482. // This file was cached using HTTP so we have to refetch the first packet
  483. resetFormattedData();
  484. clearPackets();
  485. }
  486. }
  487. }
  489. U32 LLTextureFetchWorker::calcWorkPriority()
  490. {
  491.   //llassert_always(mImagePriority >= 0 && mImagePriority <= LLViewerFetchedTexture::maxDecodePriority());
  492. static const F32 PRIORITY_SCALE = (F32)LLWorkerThread::PRIORITY_LOWBITS / LLViewerFetchedTexture::maxDecodePriority();
  494. mWorkPriority = (U32)(mImagePriority * PRIORITY_SCALE);
  495. return mWorkPriority;
  496. }
  498. // mWorkMutex is locked
  499. void LLTextureFetchWorker::setDesiredDiscard(S32 discard, S32 size)
  500. {
  501. bool prioritize = false;
  502. if (mDesiredDiscard != discard)
  503. {
  504. if (!haveWork())
  505. {
  506. calcWorkPriority();
  507. if (!mFetcher->mDebugPause)
  508. {
  509. U32 work_priority = mWorkPriority | LLWorkerThread::PRIORITY_HIGH;
  510. addWork(0, work_priority);
  511. }
  512. }
  513. else if (mDesiredDiscard < discard)
  514. {
  515. prioritize = true;
  516. }
  517. mDesiredDiscard = discard;
  518. mDesiredSize = size;
  519. }
  520. else if (size > mDesiredSize)
  521. {
  522. mDesiredSize = size;
  523. prioritize = true;
  524. }
  525. mDesiredSize = llmax(mDesiredSize, TEXTURE_CACHE_ENTRY_SIZE);
  526. if ((prioritize && mState == INIT) || mState == DONE)
  527. {
  528. mState = INIT;
  529. U32 work_priority = mWorkPriority | LLWorkerThread::PRIORITY_HIGH;
  530. setPriority(work_priority);
  531. }
  532. }
  534. void LLTextureFetchWorker::setImagePriority(F32 priority)
  535. {
  536. //  llassert_always(priority >= 0 && priority <= LLViewerTexture::maxDecodePriority());
  537. F32 delta = fabs(priority - mImagePriority);
  538. if (delta > (mImagePriority * .05f) || mState == DONE)
  539. {
  540. mImagePriority = priority;
  541. calcWorkPriority();
  542. U32 work_priority = mWorkPriority | (getPriority() & LLWorkerThread::PRIORITY_HIGHBITS);
  543. setPriority(work_priority);
  544. }
  545. }
  547. void LLTextureFetchWorker::resetFormattedData()
  548. {
  549. delete[] mBuffer;
  550. mBuffer = NULL;
  551. mBufferSize = 0;
  552. if (mFormattedImage.notNull())
  553. {
  554. mFormattedImage->deleteData();
  555. }
  556. mHaveAllData = FALSE;
  557. }
  559. // Called from MAIN thread
  560. void LLTextureFetchWorker::startWork(S32 param)
  561. {
  562. llassert(mFormattedImage.isNull());
  563. }
  565. #include "llviewertexturelist.h" // debug
  567. // Called from LLWorkerThread::processRequest()
  568. bool LLTextureFetchWorker::doWork(S32 param)
  569. {
  570. LLMutexLock lock(&mWorkMutex);
  572. if ((mFetcher->isQuitting() || mImagePriority < 1.0f || getFlags(LLWorkerClass::WCF_DELETE_REQUESTED)))
  573. {
  574. if (mState < WRITE_TO_CACHE)
  575. {
  576. return true; // abort
  577. }
  578. }
  580. if (mFetcher->mDebugPause)
  581. {
  582. return false; // debug: don't do any work
  583. }
  584. if (mID == mFetcher->mDebugID)
  585. {
  586. mFetcher->mDebugCount++; // for setting breakpoints
  587. }
  589. if (mState != DONE)
  590. {
  591. mFetchTimer.reset();
  592. }
  594. if (mState == INIT)
  595. {
  596. mRawImage = NULL ;
  597. mRequestedDiscard = -1;
  598. mLoadedDiscard = -1;
  599. mDecodedDiscard = -1;
  600. mRequestedSize = 0;
  601. mFileSize = 0;
  602. mCachedSize = 0;
  603. mLoaded = FALSE;
  604. mSentRequest = UNSENT;
  605. mDecoded  = FALSE;
  606. mWritten  = FALSE;
  607. delete[] mBuffer;
  608. mBuffer = NULL;
  609. mBufferSize = 0;
  610. mHaveAllData = FALSE;
  611. clearPackets(); // TODO: Shouldn't be necessary
  612. mCacheReadHandle = LLTextureCache::nullHandle();
  613. mCacheWriteHandle = LLTextureCache::nullHandle();
  614. mState = LOAD_FROM_TEXTURE_CACHE;
  615. mDesiredSize = llmax(mDesiredSize, TEXTURE_CACHE_ENTRY_SIZE); // min desired size is TEXTURE_CACHE_ENTRY_SIZE
  616. LL_DEBUGS("Texture") << mID << ": Priority: " << llformat("%8.0f",mImagePriority)
  617.  << " Desired Discard: " << mDesiredDiscard << " Desired Size: " << mDesiredSize << LL_ENDL;
  618. // fall through
  619. }
  621. if (mState == LOAD_FROM_TEXTURE_CACHE)
  622. {
  623. if (mCacheReadHandle == LLTextureCache::nullHandle())
  624. {
  625. U32 cache_priority = mWorkPriority;
  626. S32 offset = mFormattedImage.notNull() ? mFormattedImage->getDataSize() : 0;
  627. S32 size = mDesiredSize - offset;
  628. if (size <= 0)
  629. {
  630. mState = CACHE_POST;
  631. return false;
  632. }
  633. mFileSize = 0;
  634. mLoaded = FALSE;
  635. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority); // Set priority first since Responder may change it
  637. CacheReadResponder* responder = new CacheReadResponder(mFetcher, mID, mFormattedImage);
  638. if (mUrl.compare(0, 7, "file://") == 0)
  639. {
  640. // read file from local disk
  641. std::string filename = mUrl.substr(7, std::string::npos);
  642. mCacheReadHandle = mFetcher->mTextureCache->readFromCache(filename, mID, cache_priority,
  643.   offset, size, responder);
  644. }
  645. else if (mUrl.empty())
  646. {
  647. mCacheReadHandle = mFetcher->mTextureCache->readFromCache(mID, cache_priority,
  648.   offset, size, responder);
  649. }
  650. else
  651. {
  652. if (!(mUrl.compare(0, 7, "http://") == 0))
  653. {
  654. // *TODO:?remove this warning
  655. llwarns << "Unknown URL Type: " << mUrl << llendl;
  656. }
  657. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  658. mState = SEND_HTTP_REQ;
  659. delete responder;
  660. responder = NULL;
  661. }
  662. }
  664. if (mLoaded)
  665. {
  666. // Make sure request is complete. *TODO: make this auto-complete
  667. if (mFetcher->mTextureCache->readComplete(mCacheReadHandle, false))
  668. {
  669. mCacheReadHandle = LLTextureCache::nullHandle();
  670. mState = CACHE_POST;
  671. // fall through
  672. }
  673. else
  674. {
  675. return false;
  676. }
  677. }
  678. else
  679. {
  680. return false;
  681. }
  682. }
  684. if (mState == CACHE_POST)
  685. {
  686. mCachedSize = mFormattedImage.notNull() ? mFormattedImage->getDataSize() : 0;
  687. // Successfully loaded
  688. if ((mCachedSize >= mDesiredSize) || mHaveAllData)
  689. {
  690. // we have enough data, decode it
  691. llassert_always(mFormattedImage->getDataSize() > 0);
  692. mLoadedDiscard = mDesiredDiscard;
  693. mState = DECODE_IMAGE;
  694. LL_DEBUGS("Texture") << mID << ": Cached. Bytes: " << mFormattedImage->getDataSize()
  695.  << " Size: " << llformat("%dx%d",mFormattedImage->getWidth(),mFormattedImage->getHeight())
  696.  << " Desired Discard: " << mDesiredDiscard << " Desired Size: " << mDesiredSize << LL_ENDL;
  697. // fall through
  698. }
  699. else
  700. {
  701. if (mUrl.compare(0, 7, "file://") == 0)
  702. {
  703. // failed to load local file, we're done.
  704. return true;
  705. }
  706. // need more data
  707. else
  708. {
  709. LL_DEBUGS("Texture") << mID << ": Not in Cache" << LL_ENDL;
  710. mState = LOAD_FROM_NETWORK;
  711. }
  712. // fall through
  713. }
  714. }
  716. if (mState == LOAD_FROM_NETWORK)
  717. {
  718. bool get_url = gSavedSettings.getBOOL("ImagePipelineUseHTTP");
  719. if (!mUrl.empty()) get_url = false;
  720. //  if (mHost != LLHost::invalid) get_url = false;
  721. if ( get_url )
  722. {
  723. LLViewerRegion* region = NULL;
  724. if (mHost == LLHost::invalid)
  725. region = gAgent.getRegion();
  726. else
  727. region = LLWorld::getInstance()->getRegion(mHost);
  729. if (region)
  730. {
  731. std::string http_url = region->getCapability("GetTexture");
  732. if (!http_url.empty())
  733. {
  734. mUrl = http_url + "/?texture_id=" + mID.asString().c_str();
  735. }
  736. }
  737. else
  738. {
  739. // This will happen if not logged in or if a region deoes not have HTTP Texture enabled
  740. //llwarns << "Region not found for host: " << mHost << llendl;
  741. }
  742. }
  743. if (!mUrl.empty())
  744. {
  745. mState = LLTextureFetchWorker::SEND_HTTP_REQ;
  746. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  747. // don't return, fall through to next state
  748. }
  749. else if (mSentRequest == UNSENT)
  750. {
  751. // Add this to the network queue and sit here.
  752. // LLTextureFetch::update() will send off a request which will change our state
  753. mRequestedSize = mDesiredSize;
  754. mRequestedDiscard = mDesiredDiscard;
  755. mSentRequest = QUEUED;
  756. mFetcher->addToNetworkQueue(this);
  757. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
  758. return false;
  759. }
  760. else
  761. {
  762. // Shouldn't need to do anything here
  763. //llassert_always(mFetcher->mNetworkQueue.find(mID) != mFetcher->mNetworkQueue.end());
  764. // Make certain this is in the network queue
  765. //mFetcher->addToNetworkQueue(this);
  766. //setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
  767. return false;
  768. }
  769. }
  771. if (mState == LOAD_FROM_SIMULATOR)
  772. {
  773. if (mFormattedImage.isNull())
  774. {
  775. mFormattedImage = new LLImageJ2C;
  776. }
  777. if (processSimulatorPackets())
  778. {
  779. LL_DEBUGS("Texture") << mID << ": Loaded from Sim. Bytes: " << mFormattedImage->getDataSize() << LL_ENDL;
  780. mFetcher->removeFromNetworkQueue(this, false);
  781. if (mFormattedImage.isNull() || !mFormattedImage->getDataSize())
  782. {
  783. // processSimulatorPackets() failed
  784. //  llwarns << "processSimulatorPackets() failed to load buffer" << llendl;
  785. return true; // failed
  786. }
  787. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  788. mState = DECODE_IMAGE;
  789. }
  790. else
  791. {
  792. mFetcher->addToNetworkQueue(this); // failsafe
  793. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
  794. }
  795. return false;
  796. }
  798. if (mState == SEND_HTTP_REQ)
  799. {
  800. {
  801. const S32 HTTP_QUEUE_MAX_SIZE = 8;
  802. // *TODO: Integrate this with llviewerthrottle
  803. // Note: LLViewerThrottle uses dynamic throttling which makes sense for UDP,
  804. // but probably not for Textures.
  805. // Set the throttle to the entire bandwidth, assuming UDP packets will get priority
  806. // when they are needed
  807. F32 max_bandwidth = mFetcher->mMaxBandwidth;
  808. if ((mFetcher->getHTTPQueueSize() >= HTTP_QUEUE_MAX_SIZE) ||
  809. (mFetcher->getTextureBandwidth() > max_bandwidth))
  810. {
  811. // Make normal priority and return (i.e. wait until there is room in the queue)
  812. setPriority(LLWorkerThread::PRIORITY_NORMAL | mWorkPriority);
  813. return false;
  814. }
  816. mFetcher->removeFromNetworkQueue(this, false);
  818. S32 cur_size = 0;
  819. if (mFormattedImage.notNull())
  820. {
  821. cur_size = mFormattedImage->getDataSize(); // amount of data we already have
  822. if (mFormattedImage->getDiscardLevel() == 0)
  823. {
  824. // We already have all the data, just decode it
  825. mLoadedDiscard = mFormattedImage->getDiscardLevel();
  826. mState = DECODE_IMAGE;
  827. return false;
  828. }
  829. }
  830. mRequestedSize = mDesiredSize;
  831. mRequestedDiscard = mDesiredDiscard;
  832. mRequestedSize -= cur_size;
  833. S32 offset = cur_size;
  834. mBufferSize = cur_size; // This will get modified by callbackHttpGet()
  836. bool res = false;
  837. if (!mUrl.empty())
  838. {
  839. mLoaded = FALSE;
  840. mGetStatus = 0;
  841. mGetReason.clear();
  842. LL_DEBUGS("Texture") << "HTTP GET: " << mID << " Offset: " << offset
  843.  << " Bytes: " << mRequestedSize
  844.  << " Bandwidth(kbps): " << mFetcher->getTextureBandwidth() << "/" << max_bandwidth
  845.  << LL_ENDL;
  846. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
  847. mState = WAIT_HTTP_REQ;
  849. mFetcher->addToHTTPQueue(mID);
  850. // Will call callbackHttpGet when curl request completes
  851. std::vector<std::string> headers;
  852. headers.push_back("Accept: image/x-j2c");
  853. res = mFetcher->mCurlGetRequest->getByteRange(mUrl, headers, offset, mRequestedSize,
  854.   new HTTPGetResponder(mFetcher, mID, LLTimer::getTotalTime(), mRequestedSize, offset));
  855. }
  856. if (!res)
  857. {
  858. llwarns << "HTTP GET request failed for " << mID << llendl;
  859. resetFormattedData();
  860. ++mHTTPFailCount;
  861. return true; // failed
  862. }
  863. // fall through
  864. }
  865. }
  867. if (mState == WAIT_HTTP_REQ)
  868. {
  869. if (mLoaded)
  870. {
  871. S32 cur_size = mFormattedImage.notNull() ? mFormattedImage->getDataSize() : 0;
  872. if (mRequestedSize < 0)
  873. {
  874. S32 max_attempts;
  875. if (mGetStatus == HTTP_NOT_FOUND)
  876. {
  877. mHTTPFailCount = max_attempts = 1; // Don't retry
  878. llinfos << "Texture missing from server (404): " << mUrl << llendl;
  879. }
  880. else if (mGetStatus == HTTP_SERVICE_UNAVAILABLE)
  881. {
  882. // *TODO: Should probably introduce a timer here to delay future HTTP requsts
  883. // for a short time (~1s) to ease server load? Ideally the server would queue
  884. // requests instead of returning 503... we already limit the number pending.
  885. ++mHTTPFailCount;
  886. max_attempts = mHTTPFailCount+1; // Keep retrying
  887. LL_INFOS_ONCE("Texture") << "Texture server busy (503): " << mUrl << LL_ENDL;
  888. }
  889. else
  890. {
  891. const S32 HTTP_MAX_RETRY_COUNT = 3;
  892. max_attempts = HTTP_MAX_RETRY_COUNT + 1;
  893. ++mHTTPFailCount;
  894. llinfos << "HTTP GET failed for: " << mUrl
  895. << " Status: " << mGetStatus << " Reason: '" << mGetReason << "'"
  896. << " Attempt:" << mHTTPFailCount+1 << "/" << max_attempts << llendl;
  897. }
  898. if (mHTTPFailCount >= max_attempts)
  899. {
  900. if (cur_size > 0)
  901. {
  902. // Use available data
  903. mLoadedDiscard = mFormattedImage->getDiscardLevel();
  904. mState = DECODE_IMAGE;
  905. return false; 
  906. }
  907. else
  908. {
  909. resetFormattedData();
  910. return true; // failed
  911. }
  912. }
  913. else
  914. {
  915. mState = SEND_HTTP_REQ;
  916. return false; // retry
  917. }
  918. }
  920. if (mFormattedImage.isNull())
  921. {
  922. // For now, create formatted image based on extension
  923. std::string extension = gDirUtilp->getExtension(mUrl);
  924. mFormattedImage = LLImageFormatted::createFromType(LLImageBase::getCodecFromExtension(extension));
  925. if (mFormattedImage.isNull())
  926. {
  927. mFormattedImage = new LLImageJ2C; // default
  928. }
  929. }
  931. llassert_always(mBufferSize == cur_size + mRequestedSize);
  932. if (mHaveAllData)
  933. {
  934. mFileSize = mBufferSize;
  935. }
  936. U8* buffer = new U8[mBufferSize];
  937. if (cur_size > 0)
  938. {
  939. memcpy(buffer, mFormattedImage->getData(), cur_size);
  940. }
  941. memcpy(buffer + cur_size, mBuffer, mRequestedSize); // append
  942. // NOTE: setData releases current data and owns new data (buffer)
  943. mFormattedImage->setData(buffer, mBufferSize);
  944. // delete temp data
  945. delete[] mBuffer; // Note: not 'buffer' (assigned in setData())
  946. mBuffer = NULL;
  947. mBufferSize = 0;
  948. mLoadedDiscard = mRequestedDiscard;
  949. mState = DECODE_IMAGE;
  950. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  951. return false;
  952. }
  953. else
  954. {
  955. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
  956. return false;
  957. }
  958. }
  960. if (mState == DECODE_IMAGE)
  961. {
  962. static LLCachedControl<bool> textures_decode_disabled(gSavedSettings,"TextureDecodeDisabled");
  963. if(textures_decode_disabled)
  964. {
  965. // for debug use, don't decode
  966. mState = DONE;
  967. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
  968. return true;
  969. }
  971. if (mDesiredDiscard < 0)
  972. {
  973. // We aborted, don't decode
  974. mState = DONE;
  975. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
  976. return true;
  977. }
  979. if (mFormattedImage->getDataSize() <= 0)
  980. {
  981. llerrs << "Decode entered with invalid mFormattedImage. ID = " << mID << llendl;
  982. }
  983. if (mLoadedDiscard < 0)
  984. {
  985. //llerrs << "Decode entered with invalid mLoadedDiscard. ID = " << mID << llendl;
  987. //abort, don't decode
  988. mState = DONE;
  989. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
  990. return true;
  991. }
  992. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority); // Set priority first since Responder may change it
  993. mRawImage = NULL;
  994. mAuxImage = NULL;
  995. llassert_always(mFormattedImage.notNull());
  996. S32 discard = mHaveAllData ? 0 : mLoadedDiscard;
  997. U32 image_priority = LLWorkerThread::PRIORITY_NORMAL | mWorkPriority;
  998. mDecoded  = FALSE;
  999. mState = DECODE_IMAGE_UPDATE;
  1000. LL_DEBUGS("Texture") << mID << ": Decoding. Bytes: " << mFormattedImage->getDataSize() << " Discard: " << discard
  1001. << " All Data: " << mHaveAllData << LL_ENDL;
  1002. mDecodeHandle = mFetcher->mImageDecodeThread->decodeImage(mFormattedImage, image_priority, discard, mNeedsAux,
  1003.   new DecodeResponder(mFetcher, mID, this));
  1004. // fall though
  1005. }
  1007. if (mState == DECODE_IMAGE_UPDATE)
  1008. {
  1009. if (mDecoded)
  1010. {
  1011. if (mDecodedDiscard < 0)
  1012. {
  1013. LL_DEBUGS("Texture") << mID << ": Failed to Decode." << LL_ENDL;
  1014. if (mCachedSize > 0 && !mInLocalCache && mRetryAttempt == 0)
  1015. {
  1016. // Cache file should be deleted, try again
  1017. //  llwarns << mID << ": Decode of cached file failed (removed), retrying" << llendl;
  1018. llassert_always(mDecodeHandle == 0);
  1019. mFormattedImage = NULL;
  1020. ++mRetryAttempt;
  1021. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  1022. mState = INIT;
  1023. return false;
  1024. }
  1025. else
  1026. {
  1027. //  llwarns << "UNABLE TO LOAD TEXTURE: " << mID << " RETRIES: " << mRetryAttempt << llendl;
  1028. mState = DONE; // failed
  1029. }
  1030. }
  1031. else
  1032. {
  1033. llassert_always(mRawImage.notNull());
  1034. LL_DEBUGS("Texture") << mID << ": Decoded. Discard: " << mDecodedDiscard
  1035. << " Raw Image: " << llformat("%dx%d",mRawImage->getWidth(),mRawImage->getHeight()) << LL_ENDL;
  1036. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  1037. mState = WRITE_TO_CACHE;
  1038. }
  1039. // fall through
  1040. }
  1041. else
  1042. {
  1043. return false;
  1044. }
  1045. }
  1047. if (mState == WRITE_TO_CACHE)
  1048. {
  1049. if (mInLocalCache || mSentRequest == UNSENT || mFormattedImage.isNull())
  1050. {
  1051. // If we're in a local cache or we didn't actually receive any new data,
  1052. // or we failed to load anything, skip
  1053. mState = DONE;
  1054. return false;
  1055. }
  1056. S32 datasize = mFormattedImage->getDataSize();
  1057. llassert_always(datasize);
  1058. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority); // Set priority first since Responder may change it
  1059. U32 cache_priority = mWorkPriority;
  1060. mWritten = FALSE;
  1061. mState = WAIT_ON_WRITE;
  1062. CacheWriteResponder* responder = new CacheWriteResponder(mFetcher, mID);
  1063. mCacheWriteHandle = mFetcher->mTextureCache->writeToCache(mID, cache_priority,
  1064.   mFormattedImage->getData(), datasize,
  1065.   mFileSize, responder);
  1066. // fall through
  1067. }
  1069. if (mState == WAIT_ON_WRITE)
  1070. {
  1071. if (writeToCacheComplete())
  1072. {
  1073. mState = DONE;
  1074. // fall through
  1075. }
  1076. else
  1077. {
  1078. if (mDesiredDiscard < mDecodedDiscard)
  1079. {
  1080. // We're waiting for this write to complete before we can receive more data
  1081. // (we can't touch mFormattedImage until the write completes)
  1082. // Prioritize the write
  1083. mFetcher->mTextureCache->prioritizeWrite(mCacheWriteHandle);
  1084. }
  1085. return false;
  1086. }
  1087. }
  1089. if (mState == DONE)
  1090. {
  1091. if (mDecodedDiscard >= 0 && mDesiredDiscard < mDecodedDiscard)
  1092. {
  1093. // More data was requested, return to INIT
  1094. mState = INIT;
  1095. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  1096. return false;
  1097. }
  1098. else
  1099. {
  1100. setPriority(LLWorkerThread::PRIORITY_LOW | mWorkPriority);
  1101. return true;
  1102. }
  1103. }
  1105. return false;
  1106. }
  1108. // Called from MAIN thread
  1109. void LLTextureFetchWorker::endWork(S32 param, bool aborted)
  1110. {
  1111. if (mDecodeHandle != 0)
  1112. {
  1113. mFetcher->mImageDecodeThread->abortRequest(mDecodeHandle, false);
  1114. mDecodeHandle = 0;
  1115. }
  1116. mFormattedImage = NULL;
  1117. }
  1119. //////////////////////////////////////////////////////////////////////////////
  1121. // virtual
  1122. void LLTextureFetchWorker::finishWork(S32 param, bool completed)
  1123. {
  1124. // The following are required in case the work was aborted
  1125. if (mCacheReadHandle != LLTextureCache::nullHandle())
  1126. {
  1127. mFetcher->mTextureCache->readComplete(mCacheReadHandle, true);
  1128. mCacheReadHandle = LLTextureCache::nullHandle();
  1129. }
  1130. if (mCacheWriteHandle != LLTextureCache::nullHandle())
  1131. {
  1132. mFetcher->mTextureCache->writeComplete(mCacheWriteHandle, true);
  1133. mCacheWriteHandle = LLTextureCache::nullHandle();
  1134. }
  1135. }
  1137. // virtual
  1138. bool LLTextureFetchWorker::deleteOK()
  1139. {
  1140. bool delete_ok = true;
  1141. // Allow any pending reads or writes to complete
  1142. if (mCacheReadHandle != LLTextureCache::nullHandle())
  1143. {
  1144. if (mFetcher->mTextureCache->readComplete(mCacheReadHandle, true))
  1145. {
  1146. mCacheReadHandle = LLTextureCache::nullHandle();
  1147. }
  1148. else
  1149. {
  1150. delete_ok = false;
  1151. }
  1152. }
  1153. if (mCacheWriteHandle != LLTextureCache::nullHandle())
  1154. {
  1155. if (mFetcher->mTextureCache->writeComplete(mCacheWriteHandle))
  1156. {
  1157. mCacheWriteHandle = LLTextureCache::nullHandle();
  1158. }
  1159. else
  1160. {
  1161. delete_ok = false;
  1162. }
  1163. }
  1165. if ((haveWork() &&
  1166.  // not ok to delete from these states
  1167.  ((mState >= SEND_HTTP_REQ && mState <= WAIT_HTTP_REQ) ||
  1168.   (mState >= WRITE_TO_CACHE && mState <= WAIT_ON_WRITE))))
  1169. {
  1170. delete_ok = false;
  1171. }
  1173. return delete_ok;
  1174. }
  1176. void LLTextureFetchWorker::removeFromCache()
  1177. {
  1178. if (!mInLocalCache)
  1179. {
  1180. mFetcher->mTextureCache->removeFromCache(mID);
  1181. }
  1182. }
  1185. //////////////////////////////////////////////////////////////////////////////
  1187. bool LLTextureFetchWorker::processSimulatorPackets()
  1188. {
  1189. if (mFormattedImage.isNull() || mRequestedSize < 0)
  1190. {
  1191. // not sure how we got here, but not a valid state, abort!
  1192. llassert_always(mDecodeHandle == 0);
  1193. mFormattedImage = NULL;
  1194. return true;
  1195. }
  1197. if (mLastPacket >= mFirstPacket)
  1198. {
  1199. S32 buffer_size = mFormattedImage->getDataSize();
  1200. for (S32 i = mFirstPacket; i<=mLastPacket; i++)
  1201. {
  1202. llassert_always(mPackets[i]);
  1203. buffer_size += mPackets[i]->mSize;
  1204. }
  1205. bool have_all_data = mLastPacket >= mTotalPackets-1;
  1206. if (mRequestedSize <= 0)
  1207. {
  1208. // We received a packed but haven't requested anything yet (edge case)
  1209. // Return true (we're "done") since we didn't request anything
  1210. return true;
  1211. }
  1212. if (buffer_size >= mRequestedSize || have_all_data)
  1213. {
  1214. /// We have enough (or all) data
  1215. if (have_all_data)
  1216. {
  1217. mHaveAllData = TRUE;
  1218. }
  1219. S32 cur_size = mFormattedImage->getDataSize();
  1220. if (buffer_size > cur_size)
  1221. {
  1222. /// We have new data
  1223. U8* buffer = new U8[buffer_size];
  1224. S32 offset = 0;
  1225. if (cur_size > 0 && mFirstPacket > 0)
  1226. {
  1227. memcpy(buffer, mFormattedImage->getData(), cur_size);
  1228. offset = cur_size;
  1229. }
  1230. for (S32 i=mFirstPacket; i<=mLastPacket; i++)
  1231. {
  1232. memcpy(buffer + offset, mPackets[i]->mData, mPackets[i]->mSize);
  1233. offset += mPackets[i]->mSize;
  1234. }
  1235. // NOTE: setData releases current data
  1236. mFormattedImage->setData(buffer, buffer_size);
  1237. }
  1238. mLoadedDiscard = mRequestedDiscard;
  1239. return true;
  1240. }
  1241. }
  1242. return false;
  1243. }
  1245. //////////////////////////////////////////////////////////////////////////////
  1247. void LLTextureFetchWorker::callbackHttpGet(const LLChannelDescriptors& channels,
  1248.    const LLIOPipe::buffer_ptr_t& buffer,
  1249.    bool partial, bool success)
  1250. {
  1251. LLMutexLock lock(&mWorkMutex);
  1253. if (mState != WAIT_HTTP_REQ)
  1254. {
  1255. llwarns << "callbackHttpGet for unrequested fetch worker: " << mID
  1256. << " req=" << mSentRequest << " state= " << mState << llendl;
  1257. return;
  1258. }
  1259. if (mLoaded)
  1260. {
  1261. llwarns << "Duplicate callback for " << mID.asString() << llendl;
  1262. return; // ignore duplicate callback
  1263. }
  1264. if (success)
  1265. {
  1266. // get length of stream:
  1267. S32 data_size = buffer->countAfter(channels.in(), NULL);
  1269. gTextureList.sTextureBits += data_size * 8; // Approximate - does not include header bits
  1271. LL_DEBUGS("Texture") << "HTTP RECEIVED: " << mID.asString() << " Bytes: " << data_size << LL_ENDL;
  1272. if (data_size > 0)
  1273. {
  1274. // *TODO: set the formatted image data here directly to avoid the copy
  1275. mBuffer = new U8[data_size];
  1276. buffer->readAfter(channels.in(), NULL, mBuffer, data_size);
  1277. mBufferSize += data_size;
  1278. if (data_size < mRequestedSize && mRequestedDiscard == 0)
  1279. {
  1280. mHaveAllData = TRUE;
  1281. }
  1282. else if (data_size > mRequestedSize)
  1283. {
  1284. // *TODO: This shouldn't be happening any more
  1285. llwarns << "data_size = " << data_size << " > requested: " << mRequestedSize << llendl;
  1286. mHaveAllData = TRUE;
  1287. llassert_always(mDecodeHandle == 0);
  1288. mFormattedImage = NULL; // discard any previous data we had
  1289. mBufferSize = data_size;
  1290. }
  1291. }
  1292. else
  1293. {
  1294. // We requested data but received none (and no error),
  1295. // so presumably we have all of it
  1296. mHaveAllData = TRUE;
  1297. }
  1298. mRequestedSize = data_size;
  1299. }
  1300. else
  1301. {
  1302. mRequestedSize = -1; // error
  1303. }
  1304. mLoaded = TRUE;
  1305. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  1306. }
  1308. //////////////////////////////////////////////////////////////////////////////
  1310. void LLTextureFetchWorker::callbackCacheRead(bool success, LLImageFormatted* image,
  1311.  S32 imagesize, BOOL islocal)
  1312. {
  1313. LLMutexLock lock(&mWorkMutex);
  1314. if (mState != LOAD_FROM_TEXTURE_CACHE)
  1315. {
  1316. //  llwarns << "Read callback for " << mID << " with state = " << mState << llendl;
  1317. return;
  1318. }
  1319. if (success)
  1320. {
  1321. llassert_always(imagesize >= 0);
  1322. mFileSize = imagesize;
  1323. mFormattedImage = image;
  1324. mImageCodec = image->getCodec();
  1325. mInLocalCache = islocal;
  1326. if (mFileSize != 0 && mFormattedImage->getDataSize() >= mFileSize)
  1327. {
  1328. mHaveAllData = TRUE;
  1329. }
  1330. }
  1331. mLoaded = TRUE;
  1332. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  1333. }
  1335. void LLTextureFetchWorker::callbackCacheWrite(bool success)
  1336. {
  1337. LLMutexLock lock(&mWorkMutex);
  1338. if (mState != WAIT_ON_WRITE)
  1339. {
  1340. //  llwarns << "Write callback for " << mID << " with state = " << mState << llendl;
  1341. return;
  1342. }
  1343. mWritten = TRUE;
  1344. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  1345. }
  1347. //////////////////////////////////////////////////////////////////////////////
  1349. void LLTextureFetchWorker::callbackDecoded(bool success, LLImageRaw* raw, LLImageRaw* aux)
  1350. {
  1351. LLMutexLock lock(&mWorkMutex);
  1352. if (mDecodeHandle == 0)
  1353. {
  1354. return; // aborted, ignore
  1355. }
  1356. if (mState != DECODE_IMAGE_UPDATE)
  1357. {
  1358. //  llwarns << "Decode callback for " << mID << " with state = " << mState << llendl;
  1359. mDecodeHandle = 0;
  1360. return;
  1361. }
  1362. llassert_always(mFormattedImage.notNull());
  1364. mDecodeHandle = 0;
  1365. if (success)
  1366. {
  1367. llassert_always(raw);
  1368. mRawImage = raw;
  1369. mAuxImage = aux;
  1370. mDecodedDiscard = mFormattedImage->getDiscardLevel();
  1371.   LL_DEBUGS("Texture") << mID << ": Decode Finished. Discard: " << mDecodedDiscard
  1372.  << " Raw Image: " << llformat("%dx%d",mRawImage->getWidth(),mRawImage->getHeight()) << LL_ENDL;
  1373. }
  1374. else
  1375. {
  1376. llwarns << "DECODE FAILED: " << mID << " Discard: " << (S32)mFormattedImage->getDiscardLevel() << llendl;
  1377. removeFromCache();
  1378. mDecodedDiscard = -1; // Redundant, here for clarity and paranoia
  1379. }
  1380. mDecoded = TRUE;
  1381. //  llinfos << mID << " : DECODE COMPLETE " << llendl;
  1382. setPriority(LLWorkerThread::PRIORITY_HIGH | mWorkPriority);
  1383. }
  1385. //////////////////////////////////////////////////////////////////////////////
  1387. bool LLTextureFetchWorker::writeToCacheComplete()
  1388. {
  1389. // Complete write to cache
  1390. if (mCacheWriteHandle != LLTextureCache::nullHandle())
  1391. {
  1392. if (!mWritten)
  1393. {
  1394. return false;
  1395. }
  1396. if (mFetcher->mTextureCache->writeComplete(mCacheWriteHandle))
  1397. {
  1398. mCacheWriteHandle = LLTextureCache::nullHandle();
  1399. }
  1400. else
  1401. {
  1402. return false;
  1403. }
  1404. }
  1405. return true;
  1406. }
  1409. //////////////////////////////////////////////////////////////////////////////
  1410. //////////////////////////////////////////////////////////////////////////////
  1411. // public
  1413. LLTextureFetch::LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* imagedecodethread, bool threaded)
  1414. : LLWorkerThread("TextureFetch", threaded),
  1415.   mDebugCount(0),
  1416.   mDebugPause(FALSE),
  1417.   mPacketCount(0),
  1418.   mBadPacketCount(0),
  1419.   mQueueMutex(getAPRPool()),
  1420.   mNetworkQueueMutex(getAPRPool()),
  1421.   mTextureCache(cache),
  1422.   mImageDecodeThread(imagedecodethread),
  1423.   mTextureBandwidth(0),
  1424.   mCurlGetRequest(NULL)
  1425. {
  1426. mMaxBandwidth = gSavedSettings.getF32("ThrottleBandwidthKBPS");
  1427. mTextureInfo.setUpLogging(gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog"), gSavedSettings.getBOOL("LogTextureDownloadsToSimulator"), gSavedSettings.getU32("TextureLoggingThreshold"));
  1428. }
  1430. LLTextureFetch::~LLTextureFetch()
  1431. {
  1432. // ~LLQueuedThread() called here
  1433. }
  1435. bool LLTextureFetch::createRequest(const std::string& url, const LLUUID& id, const LLHost& host, F32 priority,
  1436.    S32 w, S32 h, S32 c, S32 desired_discard, bool needs_aux)
  1437. {
  1438. if (mDebugPause)
  1439. {
  1440. return false;
  1441. }
  1443. LLTextureFetchWorker* worker = getWorker(id) ;
  1444. if (worker)
  1445. {
  1446. if (worker->mHost != host)
  1447. {
  1448. llwarns << "LLTextureFetch::createRequest " << id << " called with multiple hosts: "
  1449. << host << " != " << worker->mHost << llendl;
  1450. removeRequest(worker, true);
  1451. worker = NULL;
  1452. return false;
  1453. }
  1454. }
  1456. S32 desired_size;
  1457. std::string exten = gDirUtilp->getExtension(url);
  1458. if (!url.empty() && (!exten.empty() && LLImageBase::getCodecFromExtension(exten) != IMG_CODEC_J2C))
  1459. {
  1460. // Only do partial requests for J2C at the moment
  1461. //llinfos << "Merov : LLTextureFetch::createRequest(), blocking fetch on " << url << llendl;
  1462. desired_size = MAX_IMAGE_DATA_SIZE;
  1463. desired_discard = 0;
  1464. }
  1465. else if (desired_discard == 0)
  1466. {
  1467. // if we want the entire image, and we know its size, then get it all
  1468. // (calcDataSizeJ2C() below makes assumptions about how the image
  1469. // was compressed - this code ensures that when we request the entire image,
  1470. // we really do get it.)
  1471. desired_size = MAX_IMAGE_DATA_SIZE;
  1472. }
  1473. else if (w*h*c > 0)
  1474. {
  1475. // If the requester knows the dimensions of the image,
  1476. // this will calculate how much data we need without having to parse the header
  1478. desired_size = LLImageJ2C::calcDataSizeJ2C(w, h, c, desired_discard);
  1479. }
  1480. else
  1481. {
  1482. desired_size = TEXTURE_CACHE_ENTRY_SIZE;
  1483. desired_discard = MAX_DISCARD_LEVEL;
  1484. }
  1487. if (worker)
  1488. {
  1489. if (worker->wasAborted())
  1490. {
  1491. return false; // need to wait for previous aborted request to complete
  1492. }
  1493. worker->lockWorkMutex();
  1494. worker->mActiveCount++;
  1495. worker->mNeedsAux = needs_aux;
  1496. worker->setImagePriority(priority);
  1497. worker->setDesiredDiscard(desired_discard, desired_size);
  1498. if (!worker->haveWork())
  1499. {
  1500. worker->mState = LLTextureFetchWorker::INIT;
  1501. worker->unlockWorkMutex();
  1503. worker->addWork(0, LLWorkerThread::PRIORITY_HIGH | worker->mWorkPriority);
  1504. }
  1505. else
  1506. {
  1507. worker->unlockWorkMutex();
  1508. }
  1509. }
  1510. else
  1511. {
  1512. worker = new LLTextureFetchWorker(this, url, id, host, priority, desired_discard, desired_size);
  1513. lockQueue() ;
  1514. mRequestMap[id] = worker;
  1515. unlockQueue() ;
  1517. worker->lockWorkMutex();
  1518. worker->mActiveCount++;
  1519. worker->mNeedsAux = needs_aux;
  1520. worker->unlockWorkMutex();
  1521. }
  1523. //  llinfos << "REQUESTED: " << id << " Discard: " << desired_discard << llendl;
  1524. return true;
  1525. }
  1527. // protected
  1528. void LLTextureFetch::addToNetworkQueue(LLTextureFetchWorker* worker)
  1529. {
  1530. lockQueue() ;
  1531. bool in_request_map = (mRequestMap.find(worker->mID) != mRequestMap.end()) ;
  1532. unlockQueue() ;
  1534. LLMutexLock lock(&mNetworkQueueMutex);
  1535. if (in_request_map)
  1536. {
  1537. // only add to the queue if in the request map
  1538. // i.e. a delete has not been requested
  1539. mNetworkQueue.insert(worker->mID);
  1540. }
  1541. for (cancel_queue_t::iterator iter1 = mCancelQueue.begin();
  1542.  iter1 != mCancelQueue.end(); ++iter1)
  1543. {
  1544. iter1->second.erase(worker->mID);
  1545. }
  1546. }
  1548. void LLTextureFetch::removeFromNetworkQueue(LLTextureFetchWorker* worker, bool cancel)
  1549. {
  1550. LLMutexLock lock(&mNetworkQueueMutex);
  1551. size_t erased = mNetworkQueue.erase(worker->mID);
  1552. if (cancel && erased > 0)
  1553. {
  1554. mCancelQueue[worker->mHost].insert(worker->mID);
  1555. }
  1556. }
  1558. // protected
  1559. void LLTextureFetch::addToHTTPQueue(const LLUUID& id)
  1560. {
  1561. LLMutexLock lock(&mNetworkQueueMutex);
  1562. mHTTPTextureQueue.insert(id);
  1563. }
  1565. void LLTextureFetch::removeFromHTTPQueue(const LLUUID& id)
  1566. {
  1567. LLMutexLock lock(&mNetworkQueueMutex);
  1568. mHTTPTextureQueue.erase(id);
  1569. }
  1571. void LLTextureFetch::deleteRequest(const LLUUID& id, bool cancel)
  1572. {
  1573. lockQueue() ;
  1574. LLTextureFetchWorker* worker = getWorkerAfterLock(id);
  1575. if (worker)
  1576. {
  1577. size_t erased_1 = mRequestMap.erase(worker->mID);
  1578. unlockQueue() ;
  1580. llassert_always(erased_1 > 0) ;
  1582. removeFromNetworkQueue(worker, cancel);
  1583. llassert_always(!(worker->getFlags(LLWorkerClass::WCF_DELETE_REQUESTED))) ;
  1585. worker->scheduleDelete();
  1586. }
  1587. else
  1588. {
  1589. unlockQueue() ;
  1590. }
  1591. }
  1593. void LLTextureFetch::removeRequest(LLTextureFetchWorker* worker, bool cancel)
  1594. {
  1595. lockQueue() ;
  1596. size_t erased_1 = mRequestMap.erase(worker->mID);
  1597. unlockQueue() ;
  1599. llassert_always(erased_1 > 0) ;
  1600. removeFromNetworkQueue(worker, cancel);
  1601. llassert_always(!(worker->getFlags(LLWorkerClass::WCF_DELETE_REQUESTED))) ;
  1603. worker->scheduleDelete();
  1604. }
  1606. S32 LLTextureFetch::getNumRequests() 
  1607. { 
  1608. lockQueue() ;
  1609. S32 size = (S32)mRequestMap.size(); 
  1610. unlockQueue() ;
  1612. return size ;
  1613. }
  1615. S32 LLTextureFetch::getNumHTTPRequests() 
  1616. { 
  1617. mNetworkQueueMutex.lock() ;
  1618. S32 size = (S32)mHTTPTextureQueue.size(); 
  1619. mNetworkQueueMutex.unlock() ;
  1621. return size ;
  1622. }
  1624. // call lockQueue() first!
  1625. LLTextureFetchWorker* LLTextureFetch::getWorkerAfterLock(const LLUUID& id)
  1626. {
  1627. LLTextureFetchWorker* res = NULL;
  1628. map_t::iterator iter = mRequestMap.find(id);
  1629. if (iter != mRequestMap.end())
  1630. {
  1631. res = iter->second;
  1632. }
  1633. return res;
  1634. }
  1636. LLTextureFetchWorker* LLTextureFetch::getWorker(const LLUUID& id)
  1637. {
  1638. LLMutexLock lock(&mQueueMutex) ;
  1640. return getWorkerAfterLock(id) ;
  1641. }
  1644. bool LLTextureFetch::getRequestFinished(const LLUUID& id, S32& discard_level,
  1645. LLPointer<LLImageRaw>& raw, LLPointer<LLImageRaw>& aux)
  1646. {
  1647. bool res = false;
  1648. LLTextureFetchWorker* worker = getWorker(id);
  1649. if (worker)
  1650. {
  1651. if (worker->wasAborted())
  1652. {
  1653. res = true;
  1654. }
  1655. else if (!worker->haveWork())
  1656. {
  1657. // Should only happen if we set mDebugPause...
  1658. if (!mDebugPause)
  1659. {
  1660. //  llwarns << "Adding work for inactive worker: " << id << llendl;
  1661. worker->addWork(0, LLWorkerThread::PRIORITY_HIGH | worker->mWorkPriority);
  1662. }
  1663. }
  1664. else if (worker->checkWork())
  1665. {
  1666. worker->lockWorkMutex();
  1667. discard_level = worker->mDecodedDiscard;
  1668. raw = worker->mRawImage;
  1669. aux = worker->mAuxImage;
  1670. res = true;
  1671. LL_DEBUGS("Texture") << id << ": Request Finished. State: " << worker->mState << " Discard: " << discard_level << LL_ENDL;
  1672. worker->unlockWorkMutex();
  1673. }
  1674. else
  1675. {
  1676. worker->lockWorkMutex();
  1677. if ((worker->mDecodedDiscard >= 0) &&
  1678. (worker->mDecodedDiscard < discard_level || discard_level < 0) &&
  1679. (worker->mState >= LLTextureFetchWorker::WAIT_ON_WRITE))
  1680. {
  1681. // Not finished, but data is ready
  1682. discard_level = worker->mDecodedDiscard;
  1683. raw = worker->mRawImage;
  1684. aux = worker->mAuxImage;
  1685. }
  1686. worker->unlockWorkMutex();
  1687. }
  1688. }
  1689. else
  1690. {
  1691. res = true;
  1692. }
  1693. return res;
  1694. }
  1696. bool LLTextureFetch::updateRequestPriority(const LLUUID& id, F32 priority)
  1697. {
  1698. bool res = false;
  1699. LLTextureFetchWorker* worker = getWorker(id);
  1700. if (worker)
  1701. {
  1702. worker->lockWorkMutex();
  1703. worker->setImagePriority(priority);
  1704. worker->unlockWorkMutex();
  1705. res = true;
  1706. }
  1707. return res;
  1708. }
  1710. //////////////////////////////////////////////////////////////////////////////
  1712. // MAIN THREAD
  1713. //virtual
  1714. S32 LLTextureFetch::update(U32 max_time_ms)
  1715. {
  1716. S32 res;
  1718. mMaxBandwidth = gSavedSettings.getF32("ThrottleBandwidthKBPS");
  1720. res = LLWorkerThread::update(max_time_ms);
  1722. if (!mDebugPause)
  1723. {
  1724. sendRequestListToSimulators();
  1725. }
  1727. if (!mThreaded)
  1728. {
  1729. // Update Curl on same thread as mCurlGetRequest was constructed
  1730. S32 processed = mCurlGetRequest->process();
  1731. if (processed > 0)
  1732. {
  1733. lldebugs << "processed: " << processed << " messages." << llendl;
  1734. }
  1735. }
  1737. return res;
  1738. }
  1740. // WORKER THREAD
  1741. void LLTextureFetch::startThread()
  1742. {
  1743. // Construct mCurlGetRequest from Worker Thread
  1744. mCurlGetRequest = new LLCurlRequest();
  1745. }
  1747. // WORKER THREAD
  1748. void LLTextureFetch::endThread()
  1749. {
  1750. // Destroy mCurlGetRequest from Worker Thread
  1751. delete mCurlGetRequest;
  1752. mCurlGetRequest = NULL;
  1753. }
  1755. // WORKER THREAD
  1756. void LLTextureFetch::threadedUpdate()
  1757. {
  1758. llassert_always(mCurlGetRequest);
  1760. // Limit update frequency
  1761. const F32 PROCESS_TIME = 0.05f; 
  1762. static LLFrameTimer process_timer;
  1763. if (process_timer.getElapsedTimeF32() < PROCESS_TIME)
  1764. {
  1765. return;
  1766. }
  1767. process_timer.reset();
  1769. // Update Curl on same thread as mCurlGetRequest was constructed
  1770. S32 processed = mCurlGetRequest->process();
  1771. if (processed > 0)
  1772. {
  1773. lldebugs << "processed: " << processed << " messages." << llendl;
  1774. }
  1776. #if 0
  1777. const F32 INFO_TIME = 1.0f; 
  1778. static LLFrameTimer info_timer;
  1779. if (info_timer.getElapsedTimeF32() >= INFO_TIME)
  1780. {
  1781. S32 q = mCurlGetRequest->getQueued();
  1782. if (q > 0)
  1783. {
  1784. llinfos << "Queued gets: " << q << llendl;
  1785. info_timer.reset();
  1786. }
  1787. }
  1788. #endif
  1790. }
  1792. //////////////////////////////////////////////////////////////////////////////
  1794. void LLTextureFetch::sendRequestListToSimulators()
  1795. {
  1796. // All requests
  1797. const F32 REQUEST_DELTA_TIME = 0.10f; // 10 fps
  1799. // Sim requests
  1800. const S32 IMAGES_PER_REQUEST = 50;
  1801. const F32 SIM_LAZY_FLUSH_TIMEOUT = 10.0f; // temp
  1802. const F32 MIN_REQUEST_TIME = 1.0f;
  1803. const F32 MIN_DELTA_PRIORITY = 1000.f;
  1805. // Periodically, gather the list of textures that need data from the network
  1806. // And send the requests out to the simulators
  1807. static LLFrameTimer timer;
  1808. if (timer.getElapsedTimeF32() < REQUEST_DELTA_TIME)
  1809. {
  1810. return;
  1811. }
  1812. timer.reset();
  1814. // Send requests
  1815. typedef std::set<LLTextureFetchWorker*,LLTextureFetchWorker::Compare> request_list_t;
  1816. typedef std::map< LLHost, request_list_t > work_request_map_t;
  1817. work_request_map_t requests;
  1818. {
  1819. LLMutexLock lock2(&mNetworkQueueMutex);
  1820. for (queue_t::iterator iter = mNetworkQueue.begin(); iter != mNetworkQueue.end(); )
  1821. {
  1822. queue_t::iterator curiter = iter++;
  1823. LLTextureFetchWorker* req = getWorker(*curiter);
  1824. if (!req)
  1825. {
  1826. mNetworkQueue.erase(curiter);
  1827. continue; // paranoia
  1828. }
  1829. if ((req->mState != LLTextureFetchWorker::LOAD_FROM_NETWORK) &&
  1830. (req->mState != LLTextureFetchWorker::LOAD_FROM_SIMULATOR))
  1831. {
  1832. // We already received our URL, remove from the queue
  1833. llwarns << "Worker: " << req->mID << " in mNetworkQueue but in wrong state: " << req->mState << llendl;
  1834. mNetworkQueue.erase(curiter);
  1835. continue;
  1836. }
  1837. if (req->mID == mDebugID)
  1838. {
  1839. mDebugCount++; // for setting breakpoints
  1840. }
  1841. if (req->mSentRequest == LLTextureFetchWorker::SENT_SIM &&
  1842. req->mTotalPackets > 0 &&
  1843. req->mLastPacket >= req->mTotalPackets-1)
  1844. {
  1845. // We have all the packets... make sure this is high priority
  1846. //  req->setPriority(LLWorkerThread::PRIORITY_HIGH | req->mWorkPriority);
  1847. continue;
  1848. }
  1849. F32 elapsed = req->mRequestedTimer.getElapsedTimeF32();
  1850. {
  1851. F32 delta_priority = llabs(req->mRequestedPriority - req->mImagePriority);
  1852. if ((req->mSimRequestedDiscard != req->mDesiredDiscard) ||
  1853. (delta_priority > MIN_DELTA_PRIORITY && elapsed >= MIN_REQUEST_TIME) ||
  1854. (elapsed >= SIM_LAZY_FLUSH_TIMEOUT))
  1855. {
  1856. requests[req->mHost].insert(req);
  1857. }
  1858. }
  1859. }
  1860. }
  1862. for (work_request_map_t::iterator iter1 = requests.begin();
  1863.  iter1 != requests.end(); ++iter1)
  1864. {
  1865. LLHost host = iter1->first;
  1866. // invalid host = use agent host
  1867. if (host == LLHost::invalid)
  1868. {
  1869. host = gAgent.getRegionHost();
  1870. }
  1872. S32 sim_request_count = 0;
  1874. for (request_list_t::iterator iter2 = iter1->second.begin();
  1875.  iter2 != iter1->second.end(); ++iter2)
  1876. {
  1877. LLTextureFetchWorker* req = *iter2;
  1878. if (gMessageSystem)
  1879. {
  1880. if (req->mSentRequest != LLTextureFetchWorker::SENT_SIM)
  1881. {
  1882. // Initialize packet data based on data read from cache
  1883. req->lockWorkMutex();
  1884. req->setupPacketData();
  1885. req->unlockWorkMutex();
  1886. }
  1887. if (0 == sim_request_count)
  1888. {
  1889. gMessageSystem->newMessageFast(_PREHASH_RequestImage);
  1890. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  1891. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  1892. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1893. }
  1894. S32 packet = req->mLastPacket + 1;
  1895. gMessageSystem->nextBlockFast(_PREHASH_RequestImage);
  1896. gMessageSystem->addUUIDFast(_PREHASH_Image, req->mID);
  1897. gMessageSystem->addS8Fast(_PREHASH_DiscardLevel, (S8)req->mDesiredDiscard);
  1898. gMessageSystem->addF32Fast(_PREHASH_DownloadPriority, req->mImagePriority);
  1899. gMessageSystem->addU32Fast(_PREHASH_Packet, packet);
  1900. gMessageSystem->addU8Fast(_PREHASH_Type, req->mType);
  1901. //  llinfos << "IMAGE REQUEST: " << req->mID << " Discard: " << req->mDesiredDiscard
  1902. //  << " Packet: " << packet << " Priority: " << req->mImagePriority << llendl;
  1904. if ((gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog")) || (gSavedSettings.getBOOL("LogTextureDownloadsToSimulator")))
  1905. {
  1906. mTextureInfo.setRequestStartTime(req->mID, LLTimer::getTotalTime());
  1907. mTextureInfo.setRequestOffset(req->mID, 0);
  1908. mTextureInfo.setRequestSize(req->mID, 0);
  1909. mTextureInfo.setRequestType(req->mID, LLTextureInfoDetails::REQUEST_TYPE_UDP);
  1910. }
  1912. req->lockWorkMutex();
  1913. req->mSentRequest = LLTextureFetchWorker::SENT_SIM;
  1914. req->mSimRequestedDiscard = req->mDesiredDiscard;
  1915. req->mRequestedPriority = req->mImagePriority;
  1916. req->mRequestedTimer.reset();
  1917. req->unlockWorkMutex();
  1918. sim_request_count++;
  1919. if (sim_request_count >= IMAGES_PER_REQUEST)
  1920. {
  1921. //  llinfos << "REQUESTING " << sim_request_count << " IMAGES FROM HOST: " << host.getIPString() << llendl;
  1923. gMessageSystem->sendSemiReliable(host, NULL, NULL);
  1924. sim_request_count = 0;
  1925. }
  1926. }
  1927. }
  1928. if (gMessageSystem && sim_request_count > 0 && sim_request_count < IMAGES_PER_REQUEST)
  1929. {
  1930. //  llinfos << "REQUESTING " << sim_request_count << " IMAGES FROM HOST: " << host.getIPString() << llendl;
  1931. gMessageSystem->sendSemiReliable(host, NULL, NULL);
  1932. sim_request_count = 0;
  1933. }
  1934. }
  1936. // Send cancelations
  1937. {
  1938. LLMutexLock lock2(&mNetworkQueueMutex);
  1939. if (gMessageSystem && !mCancelQueue.empty())
  1940. {
  1941. for (cancel_queue_t::iterator iter1 = mCancelQueue.begin();
  1942.  iter1 != mCancelQueue.end(); ++iter1)
  1943. {
  1944. LLHost host = iter1->first;
  1945. if (host == LLHost::invalid)
  1946. {
  1947. host = gAgent.getRegionHost();
  1948. }
  1949. S32 request_count = 0;
  1950. for (queue_t::iterator iter2 = iter1->second.begin();
  1951.  iter2 != iter1->second.end(); ++iter2)
  1952. {
  1953. if (0 == request_count)
  1954. {
  1955. gMessageSystem->newMessageFast(_PREHASH_RequestImage);
  1956. gMessageSystem->nextBlockFast(_PREHASH_AgentData);
  1957. gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  1958. gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1959. }
  1960. gMessageSystem->nextBlockFast(_PREHASH_RequestImage);
  1961. gMessageSystem->addUUIDFast(_PREHASH_Image, *iter2);
  1962. gMessageSystem->addS8Fast(_PREHASH_DiscardLevel, -1);
  1963. gMessageSystem->addF32Fast(_PREHASH_DownloadPriority, 0);
  1964. gMessageSystem->addU32Fast(_PREHASH_Packet, 0);
  1965. gMessageSystem->addU8Fast(_PREHASH_Type, 0);
  1966. //  llinfos << "CANCELING IMAGE REQUEST: " << (*iter2) << llendl;
  1968. request_count++;
  1969. if (request_count >= IMAGES_PER_REQUEST)
  1970. {
  1971. gMessageSystem->sendSemiReliable(host, NULL, NULL);
  1972. request_count = 0;
  1973. }
  1974. }
  1975. if (request_count > 0 && request_count < IMAGES_PER_REQUEST)
  1976. {
  1977. gMessageSystem->sendSemiReliable(host, NULL, NULL);
  1978. }
  1979. }
  1980. mCancelQueue.clear();
  1981. }
  1982. }
  1983. }
  1985. //////////////////////////////////////////////////////////////////////////////
  1987. bool LLTextureFetchWorker::insertPacket(S32 index, U8* data, S32 size)
  1988. {
  1989. mRequestedTimer.reset();
  1990. if (index >= mTotalPackets)
  1991. {
  1992. //  llwarns << "Received Image Packet " << index << " > max: " << mTotalPackets << " for image: " << mID << llendl;
  1993. return false;
  1994. }
  1995. if (index > 0 && index < mTotalPackets-1 && size != MAX_IMG_PACKET_SIZE)
  1996. {
  1997. //  llwarns << "Received bad sized packet: " << index << ", " << size << " != " << MAX_IMG_PACKET_SIZE << " for image: " << mID << llendl;
  1998. return false;
  1999. }
  2001. if (index >= (S32)mPackets.size())
  2002. {
  2003. mPackets.resize(index+1, (PacketData*)NULL); // initializes v to NULL pointers
  2004. }
  2005. else if (mPackets[index] != NULL)
  2006. {
  2007. //  llwarns << "Received duplicate packet: " << index << " for image: " << mID << llendl;
  2008. return false;
  2009. }
  2011. mPackets[index] = new PacketData(data, size);
  2012. while (mLastPacket+1 < (S32)mPackets.size() && mPackets[mLastPacket+1] != NULL)
  2013. {
  2014. ++mLastPacket;
  2015. }
  2016. return true;
  2017. }
  2019. bool LLTextureFetch::receiveImageHeader(const LLHost& host, const LLUUID& id, U8 codec, U16 packets, U32 totalbytes,
  2020. U16 data_size, U8* data)
  2021. {
  2022. LLTextureFetchWorker* worker = getWorker(id);
  2023. bool res = true;
  2025. ++mPacketCount;
  2027. if (!worker)
  2028. {
  2029. //  llwarns << "Received header for non active worker: " << id << llendl;
  2030. res = false;
  2031. }
  2032. else if (worker->mState != LLTextureFetchWorker::LOAD_FROM_NETWORK ||
  2033.  worker->mSentRequest != LLTextureFetchWorker::SENT_SIM)
  2034. {
  2035. //  llwarns << "receiveImageHeader for worker: " << id
  2036. //  << " in state: " << LLTextureFetchWorker::sStateDescs[worker->mState]
  2037. //  << " sent: " << worker->mSentRequest << llendl;
  2038. res = false;
  2039. }
  2040. else if (worker->mLastPacket != -1)
  2041. {
  2042. // check to see if we've gotten this packet before
  2043. //  llwarns << "Received duplicate header for: " << id << llendl;
  2044. res = false;
  2045. }
  2046. else if (!data_size)
  2047. {
  2048. //  llwarns << "Img: " << id << ":" << " Empty Image Header" << llendl;
  2049. res = false;
  2050. }
  2051. if (!res)
  2052. {
  2053. ++mBadPacketCount;
  2054. mNetworkQueueMutex.lock() ;
  2055. mCancelQueue[host].insert(id);
  2056. mNetworkQueueMutex.unlock() ;
  2057. return false;
  2058. }
  2060. worker->lockWorkMutex();
  2062. // Copy header data into image object
  2063. worker->mImageCodec = codec;
  2064. worker->mTotalPackets = packets;
  2065. worker->mFileSize = (S32)totalbytes;
  2066. llassert_always(totalbytes > 0);
  2067. llassert_always(data_size == FIRST_PACKET_SIZE || data_size == worker->mFileSize);
  2068. res = worker->insertPacket(0, data, data_size);
  2069. worker->setPriority(LLWorkerThread::PRIORITY_HIGH | worker->mWorkPriority);
  2070. worker->mState = LLTextureFetchWorker::LOAD_FROM_SIMULATOR;
  2071. worker->unlockWorkMutex();
  2072. return res;
  2073. }
  2075. bool LLTextureFetch::receiveImagePacket(const LLHost& host, const LLUUID& id, U16 packet_num, U16 data_size, U8* data)
  2076. {
  2077. LLTextureFetchWorker* worker = getWorker(id);
  2078. bool res = true;
  2080. ++mPacketCount;
  2082. if (!worker)
  2083. {
  2084. //  llwarns << "Received packet " << packet_num << " for non active worker: " << id << llendl;
  2085. res = false;
  2086. }
  2087. else if (worker->mLastPacket == -1)
  2088. {
  2089. //  llwarns << "Received packet " << packet_num << " before header for: " << id << llendl;
  2090. res = false;
  2091. }
  2092. else if (!data_size)
  2093. {
  2094. //  llwarns << "Img: " << id << ":" << " Empty Image Header" << llendl;
  2095. res = false;
  2096. }
  2097. if (!res)
  2098. {
  2099. ++mBadPacketCount;
  2100. mNetworkQueueMutex.lock() ;
  2101. mCancelQueue[host].insert(id);
  2102. mNetworkQueueMutex.unlock() ;
  2103. return false;
  2104. }
  2106. worker->lockWorkMutex();
  2108. res = worker->insertPacket(packet_num, data, data_size);
  2110. if ((worker->mState == LLTextureFetchWorker::LOAD_FROM_SIMULATOR) ||
  2111. (worker->mState == LLTextureFetchWorker::LOAD_FROM_NETWORK))
  2112. {
  2113. worker->setPriority(LLWorkerThread::PRIORITY_HIGH | worker->mWorkPriority);
  2114. worker->mState = LLTextureFetchWorker::LOAD_FROM_SIMULATOR;
  2115. }
  2116. else
  2117. {
  2118. //  llwarns << "receiveImagePacket " << packet_num << "/" << worker->mLastPacket << " for worker: " << id
  2119. //  << " in state: " << LLTextureFetchWorker::sStateDescs[worker->mState] << llendl;
  2120. removeFromNetworkQueue(worker, true); // failsafe
  2121. }
  2123. if(packet_num >= (worker->mTotalPackets - 1))
  2124. {
  2125. if ((gSavedSettings.getBOOL("LogTextureDownloadsToViewerLog")) || (gSavedSettings.getBOOL("LogTextureDownloadsToSimulator")))
  2126. {
  2127. U64 timeNow = LLTimer::getTotalTime();
  2128. mTextureInfo.setRequestSize(id, worker->mFileSize);
  2129. mTextureInfo.setRequestCompleteTimeAndLog(id, timeNow);
  2130. }
  2131. }
  2132. worker->unlockWorkMutex();
  2134. return res;
  2135. }
  2137. //////////////////////////////////////////////////////////////////////////////
  2138. BOOL LLTextureFetch::isFromLocalCache(const LLUUID& id)
  2139. {
  2140. BOOL from_cache = FALSE ;
  2142. LLTextureFetchWorker* worker = getWorker(id);
  2143. if (worker)
  2144. {
  2145. worker->lockWorkMutex() ;
  2146. from_cache = worker->mInLocalCache ;
  2147. worker->unlockWorkMutex() ;
  2148. }
  2150. return from_cache ;
  2151. }
  2153. S32 LLTextureFetch::getFetchState(const LLUUID& id, F32& data_progress_p, F32& requested_priority_p,
  2154.   U32& fetch_priority_p, F32& fetch_dtime_p, F32& request_dtime_p)
  2155. {
  2156. S32 state = LLTextureFetchWorker::INVALID;
  2157. F32 data_progress = 0.0f;
  2158. F32 requested_priority = 0.0f;
  2159. F32 fetch_dtime = 999999.f;
  2160. F32 request_dtime = 999999.f;
  2161. U32 fetch_priority = 0;
  2163. LLTextureFetchWorker* worker = getWorker(id);
  2164. if (worker && worker->haveWork())
  2165. {
  2166. worker->lockWorkMutex();
  2167. state = worker->mState;
  2168. fetch_dtime = worker->mFetchTimer.getElapsedTimeF32();
  2169. request_dtime = worker->mRequestedTimer.getElapsedTimeF32();
  2170. if (worker->mFileSize > 0)
  2171. {
  2172. if (state == LLTextureFetchWorker::LOAD_FROM_SIMULATOR)
  2173. {
  2174. S32 data_size = FIRST_PACKET_SIZE + (worker->mLastPacket-1) * MAX_IMG_PACKET_SIZE;
  2175. data_size = llmax(data_size, 0);
  2176. data_progress = (F32)data_size / (F32)worker->mFileSize;
  2177. }
  2178. else if (worker->mFormattedImage.notNull())
  2179. {
  2180. data_progress = (F32)worker->mFormattedImage->getDataSize() / (F32)worker->mFileSize;
  2181. }
  2182. }
  2183. if (state >= LLTextureFetchWorker::LOAD_FROM_NETWORK && state <= LLTextureFetchWorker::WAIT_HTTP_REQ)
  2184. {
  2185. requested_priority = worker->mRequestedPriority;
  2186. }
  2187. else
  2188. {
  2189. requested_priority = worker->mImagePriority;
  2190. }
  2191. fetch_priority = worker->getPriority();
  2192. worker->unlockWorkMutex();
  2193. }
  2194. data_progress_p = data_progress;
  2195. requested_priority_p = requested_priority;
  2196. fetch_priority_p = fetch_priority;
  2197. fetch_dtime_p = fetch_dtime;
  2198. request_dtime_p = request_dtime;
  2199. return state;
  2200. }
  2202. void LLTextureFetch::dump()
  2203. {
  2204. llinfos << "LLTextureFetch REQUESTS:" << llendl;
  2205. for (request_queue_t::iterator iter = mRequestQueue.begin();
  2206.  iter != mRequestQueue.end(); ++iter)
  2207. {
  2208. LLQueuedThread::QueuedRequest* qreq = *iter;
  2209. LLWorkerThread::WorkRequest* wreq = (LLWorkerThread::WorkRequest*)qreq;
  2210. LLTextureFetchWorker* worker = (LLTextureFetchWorker*)wreq->getWorkerClass();
  2211. llinfos << " ID: " << worker->mID
  2212. << " PRI: " << llformat("0x%08x",wreq->getPriority())
  2213. << " STATE: " << worker->sStateDescs[worker->mState]
  2214. << llendl;
  2215. }
  2216. }