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

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

游戏引擎

开发平台：

C++ Builder

llviewertexturelist.cpp：源码内容
  1. /** 
  2.  * @file llviewertexturelist.cpp
  3.  * @brief Object for managing the list of images within a region
  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 <sys/stat.h>
  37. #include "llviewertexturelist.h"
  39. #include "imageids.h"
  40. #include "llgl.h" // fot gathering stats from GL
  41. #include "llimagegl.h"
  42. #include "llimagebmp.h"
  43. #include "llimagej2c.h"
  44. #include "llimagetga.h"
  45. #include "llimagejpeg.h"
  46. #include "llimagepng.h"
  47. #include "llimageworker.h"
  49. #include "llsdserialize.h"
  50. #include "llsys.h"
  51. #include "llvfs.h"
  52. #include "llvfile.h"
  53. #include "llvfsthread.h"
  54. #include "llxmltree.h"
  55. #include "message.h"
  57. #include "lltexturecache.h"
  58. #include "lltexturefetch.h"
  59. #include "llviewercontrol.h"
  60. #include "llviewertexture.h"
  61. #include "llviewermedia.h"
  62. #include "llviewerregion.h"
  63. #include "llviewerstats.h"
  64. #include "pipeline.h"
  65. #include "llappviewer.h"
  66. #include "llxuiparser.h"
  68. ////////////////////////////////////////////////////////////////////////////
  70. void (*LLViewerTextureList::sUUIDCallback)(void **, const LLUUID&) = NULL;
  72. U32 LLViewerTextureList::sTextureBits = 0;
  73. U32 LLViewerTextureList::sTexturePackets = 0;
  74. S32 LLViewerTextureList::sNumImages = 0;
  75. LLStat LLViewerTextureList::sNumImagesStat(32, TRUE);
  76. LLStat LLViewerTextureList::sNumRawImagesStat(32, TRUE);
  77. LLStat LLViewerTextureList::sGLTexMemStat(32, TRUE);
  78. LLStat LLViewerTextureList::sGLBoundMemStat(32, TRUE);
  79. LLStat LLViewerTextureList::sRawMemStat(32, TRUE);
  80. LLStat LLViewerTextureList::sFormattedMemStat(32, TRUE);
  82. LLViewerTextureList gTextureList;
  83. static LLFastTimer::DeclareTimer FTM_PROCESS_IMAGES("Process Images");
  85. ///////////////////////////////////////////////////////////////////////////////
  87. LLViewerTextureList::LLViewerTextureList() 
  88. : mForceResetTextureStats(FALSE),
  89. mUpdateStats(FALSE),
  90. mMaxResidentTexMemInMegaBytes(0),
  91. mMaxTotalTextureMemInMegaBytes(0)
  92. {
  93. }
  95. void LLViewerTextureList::init()
  96. {
  97. sNumImages = 0;
  98. mMaxResidentTexMemInMegaBytes = 0;
  99. mMaxTotalTextureMemInMegaBytes = 0 ;
  100. if (gNoRender)
  101. {
  102. // Don't initialize GL stuff if we're not rendering.
  103. return;
  104. }
  106. mUpdateStats = TRUE;
  108. // Update how much texture RAM we're allowed to use.
  109. updateMaxResidentTexMem(0); // 0 = use current
  111. doPreloadImages();
  112. }
  115. void LLViewerTextureList::doPreloadImages()
  116. {
  117. LL_DEBUGS("ViewerImages") << "Preloading images..." << LL_ENDL;
  119. // Set the "missing asset" image
  120. LLViewerFetchedTexture::sMissingAssetImagep = LLViewerTextureManager::getFetchedTextureFromFile("missing_asset.tga", MIPMAP_NO, LLViewerFetchedTexture::BOOST_UI);
  122. // Set the "white" image
  123. LLViewerFetchedTexture::sWhiteImagep = LLViewerTextureManager::getFetchedTextureFromFile("white.tga", MIPMAP_NO, LLViewerFetchedTexture::BOOST_UI);
  125. LLUIImageList* image_list = LLUIImageList::getInstance();
  127. image_list->initFromFile();
  129. // turn off clamping and bilinear filtering for uv picking images
  130. //LLViewerFetchedTexture* uv_test = preloadUIImage("uv_test1.tga", LLUUID::null, FALSE);
  131. //uv_test->setClamp(FALSE, FALSE);
  132. //uv_test->setMipFilterNearest(TRUE, TRUE);
  133. //uv_test = preloadUIImage("uv_test2.tga", LLUUID::null, FALSE);
  134. //uv_test->setClamp(FALSE, FALSE);
  135. //uv_test->setMipFilterNearest(TRUE, TRUE);
  137. // prefetch specific UUIDs
  138. LLViewerTextureManager::getFetchedTexture(IMG_SHOT, TRUE);
  139. LLViewerTextureManager::getFetchedTexture(IMG_SMOKE_POOF, TRUE);
  140. LLViewerFetchedTexture* image = LLViewerTextureManager::getFetchedTextureFromFile("silhouette.j2c", MIPMAP_YES, LLViewerFetchedTexture::BOOST_UI);
  141. if (image) 
  142. {
  143. image->setAddressMode(LLTexUnit::TAM_WRAP);
  144. mImagePreloads.insert(image);
  145. }
  146. image = LLViewerTextureManager::getFetchedTextureFromFile("world/NoEntryLines.png", MIPMAP_YES, LLViewerFetchedTexture::BOOST_UI);
  147. if (image) 
  148. {
  149. image->setAddressMode(LLTexUnit::TAM_WRAP);
  150. mImagePreloads.insert(image);
  151. }
  152. image = LLViewerTextureManager::getFetchedTextureFromFile("world/NoEntryPassLines.png", MIPMAP_YES, LLViewerFetchedTexture::BOOST_UI);
  153. if (image) 
  154. {
  155. image->setAddressMode(LLTexUnit::TAM_WRAP);
  156. mImagePreloads.insert(image);
  157. }
  158. image = LLViewerTextureManager::getFetchedTexture(DEFAULT_WATER_NORMAL, MIPMAP_YES, LLViewerFetchedTexture::BOOST_UI);
  159. if (image) 
  160. {
  161. image->setAddressMode(LLTexUnit::TAM_WRAP);
  162. mImagePreloads.insert(image);
  163. }
  164. image = LLViewerTextureManager::getFetchedTextureFromFile("transparent.j2c", MIPMAP_YES, LLViewerFetchedTexture::BOOST_UI, LLViewerTexture::FETCHED_TEXTURE,
  165. 0,0,LLUUID("8dcd4a48-2d37-4909-9f78-f7a9eb4ef903"));
  166. if (image) 
  167. {
  168. image->setAddressMode(LLTexUnit::TAM_WRAP);
  169. mImagePreloads.insert(image);
  170. }
  172. }
  174. static std::string get_texture_list_name()
  175. {
  176. return std::string("texture_list_") + gSavedSettings.getString("LoginLocation") + ".xml";
  177. }
  179. void LLViewerTextureList::doPrefetchImages()
  180. {
  181. if (LLAppViewer::instance()->getPurgeCache())
  182. {
  183. // cache was purged, no point
  184. return;
  185. }
  187. // Pre-fetch textures from last logout
  188. LLSD imagelist;
  189. std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, get_texture_list_name());
  190. llifstream file;
  191. file.open(filename);
  192. if (file.is_open())
  193. {
  194. LLSDSerialize::fromXML(imagelist, file);
  195. }
  196. for (LLSD::array_iterator iter = imagelist.beginArray();
  197.  iter != imagelist.endArray(); ++iter)
  198. {
  199. LLSD imagesd = *iter;
  200. LLUUID uuid = imagesd["uuid"];
  201. S32 pixel_area = imagesd["area"];
  202. S32 texture_type = imagesd["type"];
  204. if(LLViewerTexture::FETCHED_TEXTURE == texture_type || LLViewerTexture::LOD_TEXTURE == texture_type)
  205. {
  206. LLViewerFetchedTexture* image = LLViewerTextureManager::getFetchedTexture(uuid, MIPMAP_TRUE, LLViewerTexture::BOOST_NONE, texture_type);
  207. if (image)
  208. {
  209. image->addTextureStats((F32)pixel_area);
  210. }
  211. }
  212. }
  213. }
  215. ///////////////////////////////////////////////////////////////////////////////
  217. LLViewerTextureList::~LLViewerTextureList()
  218. {
  219. }
  221. void LLViewerTextureList::shutdown()
  222. {
  223. // clear out preloads
  224. mImagePreloads.clear();
  226. // Write out list of currently loaded textures for precaching on startup
  227. typedef std::set<std::pair<S32,LLViewerFetchedTexture*> > image_area_list_t;
  228. image_area_list_t image_area_list;
  229. for (image_priority_list_t::iterator iter = mImageList.begin();
  230.  iter != mImageList.end(); ++iter)
  231. {
  232. LLViewerFetchedTexture* image = *iter;
  233. if (!image->hasGLTexture() ||
  234. !image->getUseDiscard() ||
  235. image->needsAux() ||
  236. image->getTargetHost() != LLHost::invalid)
  237. {
  238. continue; // avoid UI, baked, and other special images
  239. }
  240. if(!image->getBoundRecently())
  241. {
  242. continue ;
  243. }
  244. S32 desired = image->getDesiredDiscardLevel();
  245. if (desired >= 0 && desired < MAX_DISCARD_LEVEL)
  246. {
  247. S32 pixel_area = image->getWidth(desired) * image->getHeight(desired);
  248. image_area_list.insert(std::make_pair(pixel_area, image));
  249. }
  250. }
  252. LLSD imagelist;
  253. const S32 max_count = 1000;
  254. S32 count = 0;
  255. S32 image_type ;
  256. for (image_area_list_t::reverse_iterator riter = image_area_list.rbegin();
  257.  riter != image_area_list.rend(); ++riter)
  258. {
  259. LLViewerFetchedTexture* image = riter->second;
  260. image_type = (S32)image->getType() ;
  261. imagelist[count]["area"] = riter->first;
  262. imagelist[count]["uuid"] = image->getID();
  263. imagelist[count]["type"] = image_type;
  264. if (++count >= max_count)
  265. break;
  266. }
  268. if (count > 0 && !gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "").empty())
  269. {
  270. std::string filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, get_texture_list_name());
  271. llofstream file;
  272. file.open(filename);
  273. LLSDSerialize::toPrettyXML(imagelist, file);
  274. }
  276. //
  277. // Clean up "loaded" callbacks.
  278. //
  279. mCallbackList.clear();
  281. // Flush all of the references
  282. mLoadingStreamList.clear();
  283. mCreateTextureList.clear();
  285. mUUIDMap.clear();
  287. mImageList.clear();
  288. }
  290. void LLViewerTextureList::dump()
  291. {
  292. llinfos << "LLViewerTextureList::dump()" << llendl;
  293. for (image_priority_list_t::iterator it = mImageList.begin(); it != mImageList.end(); ++it)
  294. {
  295. LLViewerFetchedTexture* image = *it;
  297. llinfos << "priority " << image->getDecodePriority()
  298. << " boost " << image->getBoostLevel()
  299. << " size " << image->getWidth() << "x" << image->getHeight()
  300. << " discard " << image->getDiscardLevel()
  301. << " desired " << image->getDesiredDiscardLevel()
  302. << " http://asset.siva.lindenlab.com/" << image->getID() << ".texture"
  303. << llendl;
  304. }
  305. }
  307. void LLViewerTextureList::destroyGL(BOOL save_state)
  308. {
  309. LLImageGL::destroyGL(save_state);
  310. }
  312. void LLViewerTextureList::restoreGL()
  313. {
  314. LLImageGL::restoreGL();
  315. }
  317. /* Vertical tab container button image IDs
  318.  Seem to not decode when running app in debug.
  319.  
  320.  const LLUUID BAD_IMG_ONE("1097dcb3-aef9-8152-f471-431d840ea89e");
  321.  const LLUUID BAD_IMG_TWO("bea77041-5835-1661-f298-47e2d32b7a70");
  322.  */
  324. ///////////////////////////////////////////////////////////////////////////////
  326. LLViewerFetchedTexture* LLViewerTextureList::getImageFromFile(const std::string& filename,    
  327.    BOOL usemipmaps,
  328.    LLViewerTexture::EBoostLevel boost_priority,
  329.    S8 texture_type,
  330.    LLGLint internal_format,
  331.    LLGLenum primary_format, 
  332.    const LLUUID& force_id)
  333. {
  334. std::string full_path = gDirUtilp->findSkinnedFilename("textures", filename);
  335. if (full_path.empty())
  336. {
  337. llwarns << "Failed to find local image file: " << filename << llendl;
  338. return LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT, TRUE, LLViewerTexture::BOOST_UI);
  339. }
  341. std::string url = "file://" + full_path;
  343. return getImageFromUrl(url, usemipmaps, boost_priority, texture_type, internal_format, primary_format, force_id);
  344. }
  346. LLViewerFetchedTexture* LLViewerTextureList::getImageFromUrl(const std::string& url,
  347.    BOOL usemipmaps,
  348.    LLViewerTexture::EBoostLevel boost_priority,
  349.    S8 texture_type,
  350.    LLGLint internal_format,
  351.    LLGLenum primary_format, 
  352.    const LLUUID& force_id)
  353. {
  354. if (gNoRender)
  355. {
  356. // Never mind that this ignores image_set_id;
  357. // getImage() will handle that later.
  358. return LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT, TRUE, LLViewerTexture::BOOST_UI);
  359. }
  361. // generate UUID based on hash of filename
  362. LLUUID new_id;
  363. if (force_id.notNull())
  364. {
  365. new_id = force_id;
  366. }
  367. else
  368. {
  369. new_id.generate(url);
  370. }
  372. LLPointer<LLViewerFetchedTexture> imagep = findImage(new_id);
  374. if (imagep.isNull())
  375. {
  376. switch(texture_type)
  377. {
  378. case LLViewerTexture::FETCHED_TEXTURE:
  379. imagep = new LLViewerFetchedTexture(url, new_id, usemipmaps);
  380. break ;
  381. case LLViewerTexture::LOD_TEXTURE:
  382. imagep = new LLViewerLODTexture(url, new_id, usemipmaps);
  383. break ;
  384. default:
  385. llerrs << "Invalid texture type " << texture_type << llendl ;
  386. }
  388. if (internal_format && primary_format)
  389. {
  390. imagep->setExplicitFormat(internal_format, primary_format);
  391. }
  393. addImage(imagep);
  395. if (boost_priority != 0)
  396. {
  397. if (boost_priority == LLViewerFetchedTexture::BOOST_UI ||
  398. boost_priority == LLViewerFetchedTexture::BOOST_ICON)
  399. {
  400. imagep->dontDiscard();
  401. }
  402. imagep->setBoostLevel(boost_priority);
  403. }
  404. }
  406. imagep->setGLTextureCreated(true);
  408. return imagep;
  409. }
  412. LLViewerFetchedTexture* LLViewerTextureList::getImage(const LLUUID &image_id,        
  413.    BOOL usemipmaps,
  414.    LLViewerTexture::EBoostLevel boost_priority,
  415.    S8 texture_type,
  416.    LLGLint internal_format,
  417.    LLGLenum primary_format,
  418.    LLHost request_from_host)
  419. {
  420. // Return the image with ID image_id
  421. // If the image is not found, creates new image and
  422. // enqueues a request for transmission
  424. if ((&image_id == NULL) || image_id.isNull())
  425. {
  426. return (LLViewerTextureManager::getFetchedTexture(IMG_DEFAULT, TRUE, LLViewerTexture::BOOST_UI));
  427. }
  429. LLPointer<LLViewerFetchedTexture> imagep = findImage(image_id);
  431. if (imagep.isNull())
  432. {
  433. imagep = createImage(image_id, usemipmaps, boost_priority, texture_type, internal_format, primary_format, request_from_host) ;
  434. }
  436. imagep->setGLTextureCreated(true);
  438. return imagep;
  439. }
  441. //when this function is called, there is no such texture in the gTextureList with image_id.
  442. LLViewerFetchedTexture* LLViewerTextureList::createImage(const LLUUID &image_id,        
  443.    BOOL usemipmaps,
  444.    LLViewerTexture::EBoostLevel boost_priority,
  445.    S8 texture_type,
  446.    LLGLint internal_format,
  447.    LLGLenum primary_format,
  448.    LLHost request_from_host)
  449. {
  450. LLPointer<LLViewerFetchedTexture> imagep ;
  451. switch(texture_type)
  452. {
  453. case LLViewerTexture::FETCHED_TEXTURE:
  454. imagep = new LLViewerFetchedTexture(image_id, request_from_host, usemipmaps);
  455. break ;
  456. case LLViewerTexture::LOD_TEXTURE:
  457. imagep = new LLViewerLODTexture(image_id, request_from_host, usemipmaps);
  458. break ;
  459. default:
  460. llerrs << "Invalid texture type " << texture_type << llendl ;
  461. }
  463. if (internal_format && primary_format)
  464. {
  465. imagep->setExplicitFormat(internal_format, primary_format);
  466. }
  468. addImage(imagep);
  470. if (boost_priority != 0)
  471. {
  472. if (boost_priority == LLViewerFetchedTexture::BOOST_UI ||
  473. boost_priority == LLViewerFetchedTexture::BOOST_ICON)
  474. {
  475. imagep->dontDiscard();
  476. }
  477. imagep->setBoostLevel(boost_priority);
  478. }
  479. else
  480. {
  481. //by default, the texure can not be removed from memory even if it is not used.
  482. //here turn this off
  483. //if this texture should be set to NO_DELETE, call setNoDelete() afterwards.
  484. imagep->forceActive() ;
  485. }
  487. return imagep ;
  488. }
  490. LLViewerFetchedTexture *LLViewerTextureList::findImage(const LLUUID &image_id)
  491. {
  492. uuid_map_t::iterator iter = mUUIDMap.find(image_id);
  493. if(iter == mUUIDMap.end())
  494. return NULL;
  495. return iter->second;
  496. }
  498. void LLViewerTextureList::addImageToList(LLViewerFetchedTexture *image)
  499. {
  500. llassert(image);
  501. if (image->isInImageList())
  502. {
  503. llerrs << "LLViewerTextureList::addImageToList - Image already in list" << llendl;
  504. }
  505. if ((mImageList.insert(image)).second != true)
  506. {
  507. llwarns << "BAD STUFF!  (mImageList.insert(image)).second != true" << llendl;
  508. }
  509. image->setInImageList(TRUE) ;
  510. }
  512. void LLViewerTextureList::removeImageFromList(LLViewerFetchedTexture *image)
  513. {
  514. llassert(image);
  515. if (!image->isInImageList())
  516. {
  517. llinfos << "RefCount: " << image->getNumRefs() << llendl ;
  518. uuid_map_t::iterator iter = mUUIDMap.find(image->getID());
  519. if(iter == mUUIDMap.end() || iter->second != image)
  520. {
  521. llinfos << "Image is not in mUUIDMap!" << llendl ;
  522. }
  523. llerrs << "LLViewerTextureList::removeImageFromList - Image not in list" << llendl;
  524. }
  525. if (mImageList.erase(image) != 1)
  526.         {
  527.                 llwarns << "BAD STUFF!  mImageList.erase(image) != 1" << llendl;
  528.         }
  529. image->setInImageList(FALSE) ;
  530. }
  532. void LLViewerTextureList::addImage(LLViewerFetchedTexture *new_image)
  533. {
  534. if (!new_image)
  535. {
  536. llwarning("No image to add to image list", 0);
  537. return;
  538. }
  539. LLUUID image_id = new_image->getID();
  541. LLViewerFetchedTexture *image = findImage(image_id);
  542. if (image)
  543. {
  544. llwarns << "Image with ID " << image_id << " already in list" << llendl;
  545. }
  546. sNumImages++;
  548. addImageToList(new_image);
  549. mUUIDMap[image_id] = new_image;
  550. }
  553. void LLViewerTextureList::deleteImage(LLViewerFetchedTexture *image)
  554. {
  555. if( image)
  556. {
  557. if (image->hasCallbacks())
  558. {
  559. mCallbackList.erase(image);
  560. }
  562. llverify(mUUIDMap.erase(image->getID()) == 1);
  563. sNumImages--;
  564. removeImageFromList(image);
  565. }
  566. }
  568. ///////////////////////////////////////////////////////////////////////////////
  571. ////////////////////////////////////////////////////////////////////////////
  573. void LLViewerTextureList::dirtyImage(LLViewerFetchedTexture *image)
  574. {
  575. mDirtyTextureList.insert(image);
  576. }
  578. ////////////////////////////////////////////////////////////////////////////
  579. static LLFastTimer::DeclareTimer FTM_IMAGE_MARK_DIRTY("Dirty Images");
  581. void LLViewerTextureList::updateImages(F32 max_time)
  582. {
  583. LLAppViewer::getTextureFetch()->setTextureBandwidth(LLViewerStats::getInstance()->mTextureKBitStat.getMeanPerSec());
  585. LLViewerStats::getInstance()->mNumImagesStat.addValue(sNumImages);
  586. LLViewerStats::getInstance()->mNumRawImagesStat.addValue(LLImageRaw::sRawImageCount);
  587. LLViewerStats::getInstance()->mGLTexMemStat.addValue((F32)BYTES_TO_MEGA_BYTES(LLImageGL::sGlobalTextureMemoryInBytes));
  588. LLViewerStats::getInstance()->mGLBoundMemStat.addValue((F32)BYTES_TO_MEGA_BYTES(LLImageGL::sBoundTextureMemoryInBytes));
  589. LLViewerStats::getInstance()->mRawMemStat.addValue((F32)BYTES_TO_MEGA_BYTES(LLImageRaw::sGlobalRawMemory));
  590. LLViewerStats::getInstance()->mFormattedMemStat.addValue((F32)BYTES_TO_MEGA_BYTES(LLImageFormatted::sGlobalFormattedMemory));
  592. updateImagesDecodePriorities();
  594. F32 total_max_time = max_time;
  595. max_time -= updateImagesFetchTextures(max_time);
  597. max_time = llmax(max_time, total_max_time*.50f); // at least 50% of max_time
  598. max_time -= updateImagesCreateTextures(max_time);
  600. if (!mDirtyTextureList.empty())
  601. {
  602. LLFastTimer t(FTM_IMAGE_MARK_DIRTY);
  603. gPipeline.dirtyPoolObjectTextures(mDirtyTextureList);
  604. mDirtyTextureList.clear();
  605. }
  606. bool didone = false;
  607. for (image_list_t::iterator iter = mCallbackList.begin();
  608. iter != mCallbackList.end(); )
  609. {
  610. //trigger loaded callbacks on local textures immediately
  611. LLViewerFetchedTexture* image = *iter++;
  612. if (!image->getUrl().empty())
  613. {
  614. // Do stuff to handle callbacks, update priorities, etc.
  615. didone = image->doLoadedCallbacks();
  616. }
  617. else if (!didone)
  618. {
  619. // Do stuff to handle callbacks, update priorities, etc.
  620. didone = image->doLoadedCallbacks();
  621. }
  622. }
  623. updateImagesUpdateStats();
  624. }
  626. void LLViewerTextureList::updateImagesDecodePriorities()
  627. {
  628. // Update the decode priority for N images each frame
  629. {
  630. const size_t max_update_count = llmin((S32) (1024*gFrameIntervalSeconds) + 1, 32); //target 1024 textures per second
  631. S32 update_counter = llmin(max_update_count, mUUIDMap.size()/10);
  632. uuid_map_t::iterator iter = mUUIDMap.upper_bound(mLastUpdateUUID);
  633. while(update_counter > 0 && !mUUIDMap.empty())
  634. {
  635. if (iter == mUUIDMap.end())
  636. {
  637. iter = mUUIDMap.begin();
  638. }
  639. mLastUpdateUUID = iter->first;
  640. LLPointer<LLViewerFetchedTexture> imagep = iter->second;
  641. ++iter; // safe to incrament now
  643. //
  644. // Flush formatted images using a lazy flush
  645. //
  646. const F32 LAZY_FLUSH_TIMEOUT = 30.f; // stop decoding
  647. const F32 MAX_INACTIVE_TIME  = 50.f; // actually delete
  648. S32 min_refs = 3; // 1 for mImageList, 1 for mUUIDMap, 1 for local reference
  649. if (imagep->hasCallbacks())
  650. {
  651. min_refs++; // Add an extra reference if we're on the loaded callback list
  652. }
  653. S32 num_refs = imagep->getNumRefs();
  654. if (num_refs == min_refs)
  655. {
  656. if (imagep->getLastReferencedTimer()->getElapsedTimeF32() > LAZY_FLUSH_TIMEOUT)
  657. {
  658. // Remove the unused image from the image list
  659. deleteImage(imagep);
  660. imagep = NULL; // should destroy the image
  661. }
  662. continue;
  663. }
  664. else
  665. {
  666. if(imagep->hasSavedRawImage())
  667. {
  668. if(imagep->getElapsedLastReferencedSavedRawImageTime() > MAX_INACTIVE_TIME)
  669. {
  670. imagep->destroySavedRawImage() ;
  671. }
  672. }
  674. if(imagep->isDeleted())
  675. {
  676. continue ;
  677. }
  678. else if(imagep->isDeletionCandidate())
  679. {
  680. imagep->destroyTexture() ;
  681. continue ;
  682. }
  683. else if(imagep->isInactive())
  684. {
  685. if (imagep->getLastReferencedTimer()->getElapsedTimeF32() > MAX_INACTIVE_TIME)
  686. {
  687. imagep->setDeletionCandidate() ;
  688. }
  689. continue ;
  690. }
  691. else
  692. {
  693. imagep->getLastReferencedTimer()->reset();
  695. //reset texture state.
  696. imagep->setInactive() ;
  697. }
  698. }
  700. imagep->processTextureStats();
  701. F32 old_priority = imagep->getDecodePriority();
  702. F32 old_priority_test = llmax(old_priority, 0.0f);
  703. F32 decode_priority = imagep->calcDecodePriority();
  704. F32 decode_priority_test = llmax(decode_priority, 0.0f);
  705. // Ignore < 20% difference
  706. if ((decode_priority_test < old_priority_test * .8f) ||
  707. (decode_priority_test > old_priority_test * 1.25f))
  708. {
  709. removeImageFromList(imagep);
  710. imagep->setDecodePriority(decode_priority);
  711. addImageToList(imagep);
  712. }
  713. update_counter--;
  714. }
  715. }
  716. }
  718. /*
  719.  static U8 get_image_type(LLViewerFetchedTexture* imagep, LLHost target_host)
  720.  {
  721.  // Having a target host implies this is a baked image.  I don't
  722.  // believe that boost level has been set at this point. JC
  723.  U8 type_from_host = (target_host.isOk() 
  724.  ? LLImageBase::TYPE_AVATAR_BAKE 
  725.  : LLImageBase::TYPE_NORMAL);
  726.  S32 boost_level = imagep->getBoostLevel();
  727.  U8 type_from_boost = ( (boost_level == LLViewerFetchedTexture::BOOST_AVATAR_BAKED 
  728.  || boost_level == LLViewerFetchedTexture::BOOST_AVATAR_BAKED_SELF)
  729.  ? LLImageBase::TYPE_AVATAR_BAKE 
  730.  : LLImageBase::TYPE_NORMAL);
  731.  if (type_from_host == LLImageBase::TYPE_NORMAL
  732.  && type_from_boost == LLImageBase::TYPE_AVATAR_BAKE)
  733.  {
  734.  llwarns << "TAT: get_image_type() type_from_host doesn't match type_from_boost"
  735.  << " host " << target_host
  736.  << " boost " << imagep->getBoostLevel()
  737.  << " imageid " << imagep->getID()
  738.  << llendl;
  739.  imagep->dump();
  740.  }
  741.  return type_from_host;
  742.  }
  743.  */
  744. static LLFastTimer::DeclareTimer FTM_IMAGE_CREATE("Create Images");
  746. F32 LLViewerTextureList::updateImagesCreateTextures(F32 max_time)
  747. {
  748. if (gNoRender || gGLManager.mIsDisabled) return 0.0f;
  750. //
  751. // Create GL textures for all textures that need them (images which have been
  752. // decoded, but haven't been pushed into GL).
  753. //
  754. LLFastTimer t(FTM_IMAGE_CREATE);
  756. LLTimer create_timer;
  757. image_list_t::iterator enditer = mCreateTextureList.begin();
  758. for (image_list_t::iterator iter = mCreateTextureList.begin();
  759.  iter != mCreateTextureList.end();)
  760. {
  761. image_list_t::iterator curiter = iter++;
  762. enditer = iter;
  763. LLViewerFetchedTexture *imagep = *curiter;
  764. imagep->createTexture();
  765. if (create_timer.getElapsedTimeF32() > max_time)
  766. {
  767. break;
  768. }
  769. }
  770. mCreateTextureList.erase(mCreateTextureList.begin(), enditer);
  771. return create_timer.getElapsedTimeF32();
  772. }
  774. void LLViewerTextureList::forceImmediateUpdate(LLViewerFetchedTexture* imagep)
  775. {
  776. if(!imagep)
  777. {
  778. return ;
  779. }
  780. if(imagep->isInImageList())
  781. {
  782. removeImageFromList(imagep);
  783. }
  785. imagep->processTextureStats();
  786. F32 decode_priority = LLViewerFetchedTexture::maxDecodePriority() ;
  787. imagep->setDecodePriority(decode_priority);
  788. mImageList.insert(imagep);
  789. imagep->setInImageList(TRUE) ;
  791. return ;
  792. }
  794. F32 LLViewerTextureList::updateImagesFetchTextures(F32 max_time)
  795. {
  796. LLTimer image_op_timer;
  798. // Update the decode priority for N images each frame
  799. // Make a list with 32 high priority entries + 256 cycled entries
  800. const size_t max_priority_count = llmin((S32) (256*10.f*gFrameIntervalSeconds)+1, 32);
  801. const size_t max_update_count = llmin((S32) (1024*10.f*gFrameIntervalSeconds)+1, 256);
  803. // 32 high priority entries
  804. typedef std::vector<LLViewerFetchedTexture*> entries_list_t;
  805. entries_list_t entries;
  806. size_t update_counter = llmin(max_priority_count, mImageList.size());
  807. image_priority_list_t::iterator iter1 = mImageList.begin();
  808. while(update_counter > 0)
  809. {
  810. entries.push_back(*iter1);
  812. ++iter1;
  813. update_counter--;
  814. }
  816. // 256 cycled entries
  817. update_counter = llmin(max_update_count, mUUIDMap.size());
  818. if(update_counter > 0)
  819. {
  820. uuid_map_t::iterator iter2 = mUUIDMap.upper_bound(mLastFetchUUID);
  821. uuid_map_t::iterator iter2p = iter2;
  822. while(update_counter > 0)
  823. {
  824. if (iter2 == mUUIDMap.end())
  825. {
  826. iter2 = mUUIDMap.begin();
  827. }
  828. entries.push_back(iter2->second);
  829. iter2p = iter2++;
  830. update_counter--;
  831. }
  833. mLastFetchUUID = iter2p->first;
  834. }
  836. S32 fetch_count = 0;
  837. S32 min_count = max_priority_count + max_update_count/4;
  838. for (entries_list_t::iterator iter3 = entries.begin();
  839.  iter3 != entries.end(); )
  840. {
  841. LLPointer<LLViewerFetchedTexture> imagep = *iter3++;
  843. bool fetching = imagep->updateFetch();
  844. if (fetching)
  845. {
  846. fetch_count++;
  847. }
  848. if (min_count <= 0 && image_op_timer.getElapsedTimeF32() > max_time)
  849. {
  850. break;
  851. }
  852. min_count--;
  853. }
  854. if (fetch_count == 0)
  855. {
  856. gDebugTimers[0].pause();
  857. }
  858. else
  859. {
  860. gDebugTimers[0].unpause();
  861. }
  862. return image_op_timer.getElapsedTimeF32();
  863. }
  865. void LLViewerTextureList::updateImagesUpdateStats()
  866. {
  867. if (mUpdateStats && mForceResetTextureStats)
  868. {
  869. for (image_priority_list_t::iterator iter = mImageList.begin();
  870.  iter != mImageList.end(); )
  871. {
  872. LLViewerFetchedTexture* imagep = *iter++;
  873. imagep->resetTextureStats();
  874. }
  875. mUpdateStats = FALSE;
  876. mForceResetTextureStats = FALSE;
  877. }
  878. }
  880. void LLViewerTextureList::decodeAllImages(F32 max_time)
  881. {
  882. LLTimer timer;
  883. if(gNoRender) return;
  885. // Update texture stats and priorities
  886. std::vector<LLPointer<LLViewerFetchedTexture> > image_list;
  887. for (image_priority_list_t::iterator iter = mImageList.begin();
  888.  iter != mImageList.end(); )
  889. {
  890. LLViewerFetchedTexture* imagep = *iter++;
  891. image_list.push_back(imagep);
  892. imagep->setInImageList(FALSE) ;
  893. }
  894. mImageList.clear();
  895. for (std::vector<LLPointer<LLViewerFetchedTexture> >::iterator iter = image_list.begin();
  896.  iter != image_list.end(); ++iter)
  897. {
  898. LLViewerFetchedTexture* imagep = *iter;
  899. imagep->processTextureStats();
  900. F32 decode_priority = imagep->calcDecodePriority();
  901. imagep->setDecodePriority(decode_priority);
  902. mImageList.insert(imagep);
  903. imagep->setInImageList(TRUE) ;
  904. }
  905. image_list.clear();
  907. // Update fetch (decode)
  908. for (image_priority_list_t::iterator iter = mImageList.begin();
  909.  iter != mImageList.end(); )
  910. {
  911. LLViewerFetchedTexture* imagep = *iter++;
  912. imagep->updateFetch();
  913. }
  914. // Run threads
  915. S32 fetch_pending = 0;
  916. while (1)
  917. {
  918. LLAppViewer::instance()->getTextureCache()->update(1); // unpauses the texture cache thread
  919. LLAppViewer::instance()->getImageDecodeThread()->update(1); // unpauses the image thread
  920. fetch_pending = LLAppViewer::instance()->getTextureFetch()->update(1); // unpauses the texture fetch thread
  921. if (fetch_pending == 0 || timer.getElapsedTimeF32() > max_time)
  922. {
  923. break;
  924. }
  925. }
  926. // Update fetch again
  927. for (image_priority_list_t::iterator iter = mImageList.begin();
  928.  iter != mImageList.end(); )
  929. {
  930. LLViewerFetchedTexture* imagep = *iter++;
  931. imagep->updateFetch();
  932. }
  933. max_time -= timer.getElapsedTimeF32();
  934. max_time = llmax(max_time, .001f);
  935. F32 create_time = updateImagesCreateTextures(max_time);
  937. LL_DEBUGS("ViewerImages") << "decodeAllImages() took " << timer.getElapsedTimeF32() << " seconds. " 
  938. << " fetch_pending " << fetch_pending
  939. << " create_time " << create_time
  940. << LL_ENDL;
  941. }
  944. BOOL LLViewerTextureList::createUploadFile(const std::string& filename,
  945.  const std::string& out_filename,
  946.  const U8 codec)
  947. {
  948. // First, load the image.
  949. LLPointer<LLImageRaw> raw_image = new LLImageRaw;
  951. switch (codec)
  952. {
  953. case IMG_CODEC_BMP:
  954. {
  955. LLPointer<LLImageBMP> bmp_image = new LLImageBMP;
  957. if (!bmp_image->load(filename))
  958. {
  959. return FALSE;
  960. }
  962. if (!bmp_image->decode(raw_image, 0.0f))
  963. {
  964. return FALSE;
  965. }
  966. }
  967. break;
  968. case IMG_CODEC_TGA:
  969. {
  970. LLPointer<LLImageTGA> tga_image = new LLImageTGA;
  972. if (!tga_image->load(filename))
  973. {
  974. return FALSE;
  975. }
  977. if (!tga_image->decode(raw_image))
  978. {
  979. return FALSE;
  980. }
  982. if( (tga_image->getComponents() != 3) &&
  983.    (tga_image->getComponents() != 4) )
  984. {
  985. tga_image->setLastError( "Image files with less than 3 or more than 4 components are not supported." );
  986. return FALSE;
  987. }
  988. }
  989. break;
  990. case IMG_CODEC_JPEG:
  991. {
  992. LLPointer<LLImageJPEG> jpeg_image = new LLImageJPEG;
  994. if (!jpeg_image->load(filename))
  995. {
  996. return FALSE;
  997. }
  999. if (!jpeg_image->decode(raw_image, 0.0f))
  1000. {
  1001. return FALSE;
  1002. }
  1003. }
  1004. break;
  1005. case IMG_CODEC_PNG:
  1006. {
  1007. LLPointer<LLImagePNG> png_image = new LLImagePNG;
  1009. if (!png_image->load(filename))
  1010. {
  1011. return FALSE;
  1012. }
  1014. if (!png_image->decode(raw_image, 0.0f))
  1015. {
  1016. return FALSE;
  1017. }
  1018. }
  1019. break;
  1020. default:
  1021. return FALSE;
  1022. }
  1024. LLPointer<LLImageJ2C> compressedImage = convertToUploadFile(raw_image);
  1026. if( !compressedImage->save(out_filename) )
  1027. {
  1028. llinfos << "Couldn't create output file " << out_filename << llendl;
  1029. return FALSE;
  1030. }
  1032. // test to see if the encode and save worked.
  1033. LLPointer<LLImageJ2C> integrity_test = new LLImageJ2C;
  1034. if( !integrity_test->loadAndValidate( out_filename ) )
  1035. {
  1036. llinfos << "Image: " << out_filename << " is corrupt." << llendl;
  1037. return FALSE;
  1038. }
  1040. return TRUE;
  1041. }
  1043. // note: modifies the argument raw_image!!!!
  1044. LLPointer<LLImageJ2C> LLViewerTextureList::convertToUploadFile(LLPointer<LLImageRaw> raw_image)
  1045. {
  1046. raw_image->biasedScaleToPowerOfTwo(LLViewerFetchedTexture::MAX_IMAGE_SIZE_DEFAULT);
  1047. LLPointer<LLImageJ2C> compressedImage = new LLImageJ2C();
  1048. compressedImage->setRate(0.f);
  1050. if (gSavedSettings.getBOOL("LosslessJ2CUpload") &&
  1051. (raw_image->getWidth() * raw_image->getHeight() <= LL_IMAGE_REZ_LOSSLESS_CUTOFF * LL_IMAGE_REZ_LOSSLESS_CUTOFF))
  1052. compressedImage->setReversible(TRUE);
  1054. compressedImage->encode(raw_image, 0.0f);
  1056. return compressedImage;
  1057. }
  1059. const S32 MIN_VIDEO_RAM = 32;
  1060. const S32 MAX_VIDEO_RAM = 512; // 512MB max for performance reasons.
  1062. // Returns min setting for TextureMemory (in MB)
  1063. S32 LLViewerTextureList::getMinVideoRamSetting()
  1064. {
  1065. S32 system_ram = (S32)BYTES_TO_MEGA_BYTES(gSysMemory.getPhysicalMemoryClamped());
  1066. //min texture mem sets to 64M if total physical mem is more than 1.5GB
  1067. return (system_ram > 1500) ? 64 : MIN_VIDEO_RAM_IN_MEGA_BYTES ;
  1068. }
  1070. //static
  1071. // Returns max setting for TextureMemory (in MB)
  1072. S32 LLViewerTextureList::getMaxVideoRamSetting(bool get_recommended)
  1073. {
  1074. S32 max_texmem;
  1075. if (gGLManager.mVRAM != 0)
  1076. {
  1077. // Treat any card with < 32 MB (shudder) as having 32 MB
  1078. //  - it's going to be swapping constantly regardless
  1079. S32 max_vram = gGLManager.mVRAM;
  1080. max_vram = llmax(max_vram, getMinVideoRamSetting());
  1081. max_texmem = max_vram;
  1082. if (!get_recommended)
  1083. max_texmem *= 2;
  1084. }
  1085. else
  1086. {
  1087. if (get_recommended)
  1088. max_texmem = 128;
  1089. else
  1090. max_texmem = 512;
  1091. llwarns << "VRAM amount not detected, defaulting to " << max_texmem << " MB" << llendl;
  1092. }
  1094. S32 system_ram = (S32)BYTES_TO_MEGA_BYTES(gSysMemory.getPhysicalMemoryClamped()); // In MB
  1095. //llinfos << "*** DETECTED " << system_ram << " MB of system memory." << llendl;
  1096. if (get_recommended)
  1097. max_texmem = llmin(max_texmem, (S32)(system_ram/2));
  1098. else
  1099. max_texmem = llmin(max_texmem, (S32)(system_ram));
  1101. max_texmem = llclamp(max_texmem, getMinVideoRamSetting(), MAX_VIDEO_RAM_IN_MEGA_BYTES); 
  1103. return max_texmem;
  1104. }
  1106. const S32 VIDEO_CARD_FRAMEBUFFER_MEM = 12; // MB
  1107. const S32 MIN_MEM_FOR_NON_TEXTURE = 512 ; //MB
  1108. void LLViewerTextureList::updateMaxResidentTexMem(S32 mem)
  1109. {
  1110. // Initialize the image pipeline VRAM settings
  1111. S32 cur_mem = gSavedSettings.getS32("TextureMemory");
  1112. F32 mem_multiplier = gSavedSettings.getF32("RenderTextureMemoryMultiple");
  1113. S32 default_mem = getMaxVideoRamSetting(true); // recommended default
  1114. if (mem == 0)
  1115. {
  1116. mem = cur_mem > 0 ? cur_mem : default_mem;
  1117. }
  1118. else if (mem < 0)
  1119. {
  1120. mem = default_mem;
  1121. }
  1123. // limit the texture memory to a multiple of the default if we've found some cards to behave poorly otherwise
  1124. mem = llmin(mem, (S32) (mem_multiplier * (F32) default_mem));
  1126. mem = llclamp(mem, getMinVideoRamSetting(), getMaxVideoRamSetting());
  1127. if (mem != cur_mem)
  1128. {
  1129. gSavedSettings.setS32("TextureMemory", mem);
  1130. return; //listener will re-enter this function
  1131. }
  1133. // TODO: set available resident texture mem based on use by other subsystems
  1134. // currently max(12MB, VRAM/4) assumed...
  1136. S32 vb_mem = mem;
  1137. S32 fb_mem = llmax(VIDEO_CARD_FRAMEBUFFER_MEM, vb_mem/4);
  1138. mMaxResidentTexMemInMegaBytes = (vb_mem - fb_mem) ; //in MB
  1140. mMaxTotalTextureMemInMegaBytes = mMaxResidentTexMemInMegaBytes * 2;
  1141. if (mMaxResidentTexMemInMegaBytes > 640)
  1142. {
  1143. mMaxTotalTextureMemInMegaBytes -= (mMaxResidentTexMemInMegaBytes >> 2);
  1144. }
  1146. //system mem
  1147. S32 system_ram = (S32)BYTES_TO_MEGA_BYTES(gSysMemory.getPhysicalMemoryClamped()); // In MB
  1149. //minimum memory reserved for non-texture use.
  1150. //if system_raw >= 1GB, reserve at least 512MB for non-texture use;
  1151. //otherwise reserve half of the system_ram for non-texture use.
  1152. S32 min_non_texture_mem = llmin(system_ram / 2, MIN_MEM_FOR_NON_TEXTURE) ; 
  1154. if (mMaxTotalTextureMemInMegaBytes > system_ram - min_non_texture_mem)
  1155. {
  1156. mMaxTotalTextureMemInMegaBytes = system_ram - min_non_texture_mem ;
  1157. }
  1159. llinfos << "Total Video Memory set to: " << vb_mem << " MB" << llendl;
  1160. llinfos << "Available Texture Memory set to: " << (vb_mem - fb_mem) << " MB" << llendl;
  1161. }
  1163. ///////////////////////////////////////////////////////////////////////////////
  1165. // static
  1166. void LLViewerTextureList::receiveImageHeader(LLMessageSystem *msg, void **user_data)
  1167. {
  1168. LLFastTimer t(FTM_PROCESS_IMAGES);
  1170. // Receive image header, copy into image object and decompresses 
  1171. // if this is a one-packet image. 
  1173. LLUUID id;
  1175. char ip_string[256];
  1176. u32_to_ip_string(msg->getSenderIP(),ip_string);
  1178. if (msg->getReceiveCompressedSize())
  1179. {
  1180. gTextureList.sTextureBits += msg->getReceiveCompressedSize() * 8;
  1181. }
  1182. else
  1183. {
  1184. gTextureList.sTextureBits += msg->getReceiveSize() * 8;
  1185. }
  1186. gTextureList.sTexturePackets++;
  1188. U8 codec;
  1189. U16 packets;
  1190. U32 totalbytes;
  1191. msg->getUUIDFast(_PREHASH_ImageID, _PREHASH_ID, id);
  1192. msg->getU8Fast(_PREHASH_ImageID, _PREHASH_Codec, codec);
  1193. msg->getU16Fast(_PREHASH_ImageID, _PREHASH_Packets, packets);
  1194. msg->getU32Fast(_PREHASH_ImageID, _PREHASH_Size, totalbytes);
  1196. S32 data_size = msg->getSizeFast(_PREHASH_ImageData, _PREHASH_Data); 
  1197. if (!data_size)
  1198. {
  1199. return;
  1200. }
  1201. if (data_size < 0)
  1202. {
  1203. // msg->getSizeFast() is probably trying to tell us there
  1204. // was an error.
  1205. llerrs << "image header chunk size was negative: "
  1206. << data_size << llendl;
  1207. return;
  1208. }
  1210. // this buffer gets saved off in the packet list
  1211. U8 *data = new U8[data_size];
  1212. msg->getBinaryDataFast(_PREHASH_ImageData, _PREHASH_Data, data, data_size);
  1214. LLViewerFetchedTexture *image = LLViewerTextureManager::getFetchedTexture(id, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
  1215. if (!image)
  1216. {
  1217. delete [] data;
  1218. return;
  1219. }
  1220. image->getLastPacketTimer()->reset();
  1221. bool res = LLAppViewer::getTextureFetch()->receiveImageHeader(msg->getSender(), id, codec, packets, totalbytes, data_size, data);
  1222. if (!res)
  1223. {
  1224. delete[] data;
  1225. }
  1226. }
  1228. // static
  1229. void LLViewerTextureList::receiveImagePacket(LLMessageSystem *msg, void **user_data)
  1230. {
  1231. LLMemType mt1(LLMemType::MTYPE_APPFMTIMAGE);
  1232. LLFastTimer t(FTM_PROCESS_IMAGES);
  1234. // Receives image packet, copy into image object,
  1235. // checks if all packets received, decompresses if so. 
  1237. LLUUID id;
  1238. U16 packet_num;
  1240. char ip_string[256];
  1241. u32_to_ip_string(msg->getSenderIP(),ip_string);
  1243. if (msg->getReceiveCompressedSize())
  1244. {
  1245. gTextureList.sTextureBits += msg->getReceiveCompressedSize() * 8;
  1246. }
  1247. else
  1248. {
  1249. gTextureList.sTextureBits += msg->getReceiveSize() * 8;
  1250. }
  1251. gTextureList.sTexturePackets++;
  1253. //llprintline("Start decode, image header...");
  1254. msg->getUUIDFast(_PREHASH_ImageID, _PREHASH_ID, id);
  1255. msg->getU16Fast(_PREHASH_ImageID, _PREHASH_Packet, packet_num);
  1256. S32 data_size = msg->getSizeFast(_PREHASH_ImageData, _PREHASH_Data); 
  1258. if (!data_size)
  1259. {
  1260. return;
  1261. }
  1262. if (data_size < 0)
  1263. {
  1264. // msg->getSizeFast() is probably trying to tell us there
  1265. // was an error.
  1266. llerrs << "image data chunk size was negative: "
  1267. << data_size << llendl;
  1268. return;
  1269. }
  1270. if (data_size > MTUBYTES)
  1271. {
  1272. llerrs << "image data chunk too large: " << data_size << " bytes" << llendl;
  1273. return;
  1274. }
  1275. U8 *data = new U8[data_size];
  1276. msg->getBinaryDataFast(_PREHASH_ImageData, _PREHASH_Data, data, data_size);
  1278. LLViewerFetchedTexture *image = LLViewerTextureManager::getFetchedTexture(id, TRUE, LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
  1279. if (!image)
  1280. {
  1281. delete [] data;
  1282. return;
  1283. }
  1284. image->getLastPacketTimer()->reset();
  1285. bool res = LLAppViewer::getTextureFetch()->receiveImagePacket(msg->getSender(), id, packet_num, data_size, data);
  1286. if (!res)
  1287. {
  1288. delete[] data;
  1289. }
  1290. }
  1293. // We've been that the asset server does not contain the requested image id.
  1294. // static
  1295. void LLViewerTextureList::processImageNotInDatabase(LLMessageSystem *msg,void **user_data)
  1296. {
  1297. LLFastTimer t(FTM_PROCESS_IMAGES);
  1298. LLUUID image_id;
  1299. msg->getUUIDFast(_PREHASH_ImageID, _PREHASH_ID, image_id);
  1301. LLViewerFetchedTexture* image = gTextureList.findImage( image_id );
  1302. if( image )
  1303. {
  1304. image->setIsMissingAsset();
  1305. }
  1306. }
  1308. ///////////////////////////////////////////////////////////////////////////////
  1310. //static
  1311. const U32 SIXTEEN_MEG = 0x1000000;
  1312. S32 LLViewerTextureList::calcMaxTextureRAM()
  1313. {
  1314. // Decide the maximum amount of RAM we should allow the user to allocate to texture cache
  1315. LLMemoryInfo memory_info;
  1316. U32 available_memory = memory_info.getPhysicalMemoryClamped();
  1318. clamp_rescale((F32)available_memory,
  1319.   (F32)(SIXTEEN_MEG * 16),
  1320.   (F32)U32_MAX,
  1321.   (F32)(SIXTEEN_MEG * 4),
  1322.   (F32)(U32_MAX >> 1));
  1323. return available_memory;
  1324. }
  1326. ///////////////////////////////////////////////////////////////////////////////
  1328. // explicitly cleanup resources, as this is a singleton class with process
  1329. // lifetime so ability to perform std::map operations in destructor is not
  1330. // guaranteed.
  1331. void LLUIImageList::cleanUp()
  1332. {
  1333. mUIImages.clear();
  1334. mUITextureList.clear() ;
  1335. }
  1337. LLUIImagePtr LLUIImageList::getUIImageByID(const LLUUID& image_id, S32 priority)
  1338. {
  1339. // use id as image name
  1340. std::string image_name = image_id.asString();
  1342. // look for existing image
  1343. uuid_ui_image_map_t::iterator found_it = mUIImages.find(image_name);
  1344. if (found_it != mUIImages.end())
  1345. {
  1346. return found_it->second;
  1347. }
  1349. const BOOL use_mips = FALSE;
  1350. const LLRect scale_rect = LLRect::null;
  1351. return loadUIImageByID(image_id, use_mips, scale_rect, (LLViewerTexture::EBoostLevel)priority);
  1352. }
  1354. LLUIImagePtr LLUIImageList::getUIImage(const std::string& image_name, S32 priority)
  1355. {
  1356. // look for existing image
  1357. uuid_ui_image_map_t::iterator found_it = mUIImages.find(image_name);
  1358. if (found_it != mUIImages.end())
  1359. {
  1360. return found_it->second;
  1361. }
  1363. const BOOL use_mips = FALSE;
  1364. const LLRect scale_rect = LLRect::null;
  1365. return loadUIImageByName(image_name, image_name, use_mips, scale_rect, (LLViewerTexture::EBoostLevel)priority);
  1366. }
  1368. LLUIImagePtr LLUIImageList::loadUIImageByName(const std::string& name, const std::string& filename,
  1369.   BOOL use_mips, const LLRect& scale_rect, LLViewerTexture::EBoostLevel boost_priority )
  1370. {
  1371. if (boost_priority == LLViewerTexture::BOOST_NONE)
  1372. {
  1373. boost_priority = LLViewerTexture::BOOST_UI;
  1374. }
  1375. LLViewerFetchedTexture* imagep = LLViewerTextureManager::getFetchedTextureFromFile(filename, MIPMAP_NO, boost_priority);
  1376. return loadUIImage(imagep, name, use_mips, scale_rect);
  1377. }
  1379. LLUIImagePtr LLUIImageList::loadUIImageByID(const LLUUID& id,
  1380. BOOL use_mips, const LLRect& scale_rect, LLViewerTexture::EBoostLevel boost_priority)
  1381. {
  1382. if (boost_priority == LLViewerTexture::BOOST_NONE)
  1383. {
  1384. boost_priority = LLViewerTexture::BOOST_UI;
  1385. }
  1386. LLViewerFetchedTexture* imagep = LLViewerTextureManager::getFetchedTexture(id, MIPMAP_NO, boost_priority);
  1387. return loadUIImage(imagep, id.asString(), use_mips, scale_rect);
  1388. }
  1390. LLUIImagePtr LLUIImageList::loadUIImage(LLViewerFetchedTexture* imagep, const std::string& name, BOOL use_mips, const LLRect& scale_rect)
  1391. {
  1392. if (!imagep) return NULL;
  1394. imagep->setAddressMode(LLTexUnit::TAM_CLAMP);
  1396. //all UI images are non-deletable
  1397. imagep->setNoDelete();
  1399. LLUIImagePtr new_imagep = new LLUIImage(name, imagep);
  1400. mUIImages.insert(std::make_pair(name, new_imagep));
  1401. mUITextureList.push_back(imagep);
  1403. LLUIImageLoadData* datap = new LLUIImageLoadData;
  1404. datap->mImageName = name;
  1405. datap->mImageScaleRegion = scale_rect;
  1407. imagep->setLoadedCallback(onUIImageLoaded, 0, FALSE, FALSE, datap);
  1409. return new_imagep;
  1410. }
  1412. LLUIImagePtr LLUIImageList::preloadUIImage(const std::string& name, const std::string& filename, BOOL use_mips, const LLRect& scale_rect)
  1413. {
  1414. // look for existing image
  1415. uuid_ui_image_map_t::iterator found_it = mUIImages.find(name);
  1416. if (found_it != mUIImages.end())
  1417. {
  1418. // image already loaded!
  1419. llerrs << "UI Image " << name << " already loaded." << llendl;
  1420. }
  1422. return loadUIImageByName(name, filename, use_mips, scale_rect);
  1423. }
  1425. //static 
  1426. void LLUIImageList::onUIImageLoaded( BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* src_aux, S32 discard_level, BOOL final, void* user_data )
  1427. {
  1428. if(!success || !user_data) 
  1429. {
  1430. return;
  1431. }
  1433. LLUIImageLoadData* image_datap = (LLUIImageLoadData*)user_data;
  1434. std::string ui_image_name = image_datap->mImageName;
  1435. LLRect scale_rect = image_datap->mImageScaleRegion;
  1436. if (final)
  1437. {
  1438. delete image_datap;
  1439. }
  1441. LLUIImageList* instance = getInstance();
  1443. uuid_ui_image_map_t::iterator found_it = instance->mUIImages.find(ui_image_name);
  1444. if (found_it != instance->mUIImages.end())
  1445. {
  1446. LLUIImagePtr imagep = found_it->second;
  1448. // for images grabbed from local files, apply clipping rectangle to restore original dimensions
  1449. // from power-of-2 gl image
  1450. if (success && imagep.notNull() && src_vi && (src_vi->getUrl().compare(0, 7, "file://")==0))
  1451. {
  1452. F32 clip_x = (F32)src_vi->getOriginalWidth() / (F32)src_vi->getFullWidth();
  1453. F32 clip_y = (F32)src_vi->getOriginalHeight() / (F32)src_vi->getFullHeight();
  1454. imagep->setClipRegion(LLRectf(0.f, clip_y, clip_x, 0.f));
  1455. if (scale_rect != LLRect::null)
  1456. {
  1457. imagep->setScaleRegion(
  1458. LLRectf(llclamp((F32)scale_rect.mLeft / (F32)imagep->getWidth(), 0.f, 1.f),
  1459. llclamp((F32)scale_rect.mTop / (F32)imagep->getHeight(), 0.f, 1.f),
  1460. llclamp((F32)scale_rect.mRight / (F32)imagep->getWidth(), 0.f, 1.f),
  1461. llclamp((F32)scale_rect.mBottom / (F32)imagep->getHeight(), 0.f, 1.f)));
  1462. }
  1464. imagep->onImageLoaded();
  1465. }
  1466. }
  1467. }
  1469. struct UIImageDeclaration : public LLInitParam::Block<UIImageDeclaration>
  1470. {
  1471. Mandatory<std::string> name;
  1472. Optional<std::string> file_name;
  1473. Optional<bool> preload;
  1474. Optional<LLRect> scale;
  1475. Optional<bool> use_mips;
  1477. UIImageDeclaration()
  1478. : name("name"),
  1479. file_name("file_name"),
  1480. preload("preload", false),
  1481. scale("scale"),
  1482. use_mips("use_mips", false)
  1483. {}
  1484. };
  1486. struct UIImageDeclarations : public LLInitParam::Block<UIImageDeclarations>
  1487. {
  1488. Mandatory<S32> version;
  1489. Multiple<UIImageDeclaration> textures;
  1491. UIImageDeclarations()
  1492. : version("version"),
  1493. textures("texture")
  1494. {}
  1495. };
  1497. bool LLUIImageList::initFromFile()
  1498. {
  1499. // construct path to canonical textures.xml in default skin dir
  1500. std::string base_file_path = gDirUtilp->getExpandedFilename(LL_PATH_SKINS, "default", "textures", "textures.xml");
  1502. LLXMLNodePtr root;
  1504. if (!LLXMLNode::parseFile(base_file_path, root, NULL))
  1505. {
  1506. llwarns << "Unable to parse UI image list file " << base_file_path << llendl;
  1507. return false;
  1508. }
  1509. if (!root->hasAttribute("version"))
  1510. {
  1511. llwarns << "No valid version number in UI image list file " << base_file_path << llendl;
  1512. return false;
  1513. }
  1515. std::vector<std::string> paths;
  1516. // path to current selected skin
  1517. paths.push_back(gDirUtilp->getSkinDir() 
  1518. + gDirUtilp->getDirDelimiter() 
  1519. + "textures"
  1520. + gDirUtilp->getDirDelimiter()
  1521. + "textures.xml");
  1522. // path to user overrides on current skin
  1523. paths.push_back(gDirUtilp->getUserSkinDir() 
  1524. + gDirUtilp->getDirDelimiter() 
  1525. + "textures"
  1526. + gDirUtilp->getDirDelimiter()
  1527. + "textures.xml");
  1529. // apply skinned xml files incrementally
  1530. for(std::vector<std::string>::iterator path_it = paths.begin();
  1531. path_it != paths.end();
  1532. ++path_it)
  1533. {
  1534. // don't reapply base file to itself
  1535. if (!path_it->empty() && (*path_it) != base_file_path)
  1536. {
  1537. LLXMLNodePtr update_root;
  1538. if (LLXMLNode::parseFile(*path_it, update_root, NULL))
  1539. {
  1540. LLXMLNode::updateNode(root, update_root);
  1541. }
  1542. }
  1543. }
  1545. UIImageDeclarations images;
  1546. LLXUIParser::instance().readXUI(root, images, base_file_path);
  1548. if (!images.validateBlock()) return false;
  1550. enum e_decode_pass
  1551. {
  1552. PASS_DECODE_NOW,
  1553. PASS_DECODE_LATER,
  1554. NUM_PASSES
  1555. };
  1557. for (S32 cur_pass = PASS_DECODE_NOW; cur_pass < NUM_PASSES; cur_pass++)
  1558. {
  1559. for (LLInitParam::ParamIterator<UIImageDeclaration>::const_iterator image_it = images.textures().begin();
  1560. image_it != images.textures().end();
  1561. ++image_it)
  1562. {
  1563. std::string file_name = image_it->file_name.isProvided() ? image_it->file_name() : image_it->name();
  1565. // load high priority textures on first pass (to kick off decode)
  1566. enum e_decode_pass decode_pass = image_it->preload ? PASS_DECODE_NOW : PASS_DECODE_LATER;
  1567. if (decode_pass != cur_pass)
  1568. {
  1569. continue;
  1570. }
  1571. preloadUIImage(image_it->name, file_name, image_it->use_mips, image_it->scale);
  1572. }
  1574. if (cur_pass == PASS_DECODE_NOW && !gSavedSettings.getBOOL("NoPreload"))
  1575. {
  1576. gTextureList.decodeAllImages(10.f); // decode preloaded images
  1577. }
  1578. }
  1579. return true;
  1580. }