lltexturefetch.h
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:5k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file lltexturefetch.h
  3.  * @brief Object for managing texture fetches.
  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.  */
  32. #ifndef LL_LLTEXTUREFETCH_H
  33. #define LL_LLTEXTUREFETCH_H
  34. #include "lldir.h"
  35. #include "llimage.h"
  36. #include "lluuid.h"
  37. #include "llworkerthread.h"
  38. #include "llcurl.h"
  39. #include "lltextureinfo.h"
  40. class LLViewerTexture;
  41. class LLTextureFetchWorker;
  42. class HTTPGetResponder;
  43. class LLTextureCache;
  44. class LLImageDecodeThread;
  45. class LLHost;
  46. // Interface class
  47. class LLTextureFetch : public LLWorkerThread
  48. {
  49. friend class LLTextureFetchWorker;
  50. friend class HTTPGetResponder;
  51. public:
  52. LLTextureFetch(LLTextureCache* cache, LLImageDecodeThread* imagedecodethread, bool threaded);
  53. ~LLTextureFetch();
  54. /*virtual*/ S32 update(U32 max_time_ms);
  55. bool createRequest(const std::string& url, const LLUUID& id, const LLHost& host, F32 priority,
  56.    S32 w, S32 h, S32 c, S32 discard, bool needs_aux);
  57. void deleteRequest(const LLUUID& id, bool cancel);
  58. bool getRequestFinished(const LLUUID& id, S32& discard_level,
  59. LLPointer<LLImageRaw>& raw, LLPointer<LLImageRaw>& aux);
  60. bool updateRequestPriority(const LLUUID& id, F32 priority);
  61. bool receiveImageHeader(const LLHost& host, const LLUUID& id, U8 codec, U16 packets, U32 totalbytes, U16 data_size, U8* data);
  62. bool receiveImagePacket(const LLHost& host, const LLUUID& id, U16 packet_num, U16 data_size, U8* data);
  63. void setTextureBandwidth(F32 bandwidth) { mTextureBandwidth = bandwidth; }
  64. F32 getTextureBandwidth() { return mTextureBandwidth; }
  65. // Debug
  66. BOOL isFromLocalCache(const LLUUID& id);
  67. S32 getFetchState(const LLUUID& id, F32& decode_progress_p, F32& requested_priority_p,
  68.   U32& fetch_priority_p, F32& fetch_dtime_p, F32& request_dtime_p);
  69. void dump();
  70. S32 getNumRequests() ;
  71. S32 getNumHTTPRequests() ;
  72. // Public for access by callbacks
  73. void lockQueue() { mQueueMutex.lock(); }
  74. void unlockQueue() { mQueueMutex.unlock(); }
  75. LLTextureFetchWorker* getWorker(const LLUUID& id);
  76. LLTextureFetchWorker* getWorkerAfterLock(const LLUUID& id);
  77. LLTextureInfo* getTextureInfo() { return &mTextureInfo; }
  78. protected:
  79. void addToNetworkQueue(LLTextureFetchWorker* worker);
  80. void removeFromNetworkQueue(LLTextureFetchWorker* worker, bool cancel);
  81. void addToHTTPQueue(const LLUUID& id);
  82. void removeFromHTTPQueue(const LLUUID& id);
  83. S32 getHTTPQueueSize() { return getNumHTTPRequests(); }
  84. void removeRequest(LLTextureFetchWorker* worker, bool cancel);
  85. // Called from worker thread (during doWork)
  86. void processCurlRequests();
  87. private:
  88. void sendRequestListToSimulators();
  89. /*virtual*/ void startThread(void);
  90. /*virtual*/ void endThread(void);
  91. /*virtual*/ void threadedUpdate(void);
  92. public:
  93. LLUUID mDebugID;
  94. S32 mDebugCount;
  95. BOOL mDebugPause;
  96. S32 mPacketCount;
  97. S32 mBadPacketCount;
  98. private:
  99. LLMutex mQueueMutex;        //to protect mRequestMap only
  100. LLMutex mNetworkQueueMutex; //to protect mNetworkQueue, mHTTPTextureQueue and mCancelQueue.
  101. LLTextureCache* mTextureCache;
  102. LLImageDecodeThread* mImageDecodeThread;
  103. LLCurlRequest* mCurlGetRequest;
  104. // Map of all requests by UUID
  105. typedef std::map<LLUUID,LLTextureFetchWorker*> map_t;
  106. map_t mRequestMap;
  107. // Set of requests that require network data
  108. typedef std::set<LLUUID> queue_t;
  109. queue_t mNetworkQueue;
  110. queue_t mHTTPTextureQueue;
  111. typedef std::map<LLHost,std::set<LLUUID> > cancel_queue_t;
  112. cancel_queue_t mCancelQueue;
  113. F32 mTextureBandwidth;
  114. F32 mMaxBandwidth;
  115. LLTextureInfo mTextureInfo;
  116. };
  117. #endif // LL_LLTEXTUREFETCH_H