第二人生的源码分析(四十七)发送下载纹理图片请求

这里接着上一次获取纹理图片线程，继续分析发送纹理图片请求到服务器。代码如下：
#001 void LLTextureFetch::sendRequestListToSimulators()
#002 {
#003 const S32 IMAGES_PER_REQUEST = 50;
#004 const F32 LAZY_FLUSH_TIMEOUT = 15.f; // 10.0f // temp
#005 const F32 MIN_REQUEST_TIME = 1.0f;
#006 const F32 MIN_DELTA_PRIORITY = 1000.f;
#007

先同步多线程的访问。
#008 LLMutexLock lock(&mQueueMutex);
#009
#010 // Send requests
#011 typedef std::set<LLTextureFetchWorker*,LLTextureFetchWorker::Compare> request_list_t;
#012 typedef std::map< LLHost, request_list_t > work_request_map_t;
#013 work_request_map_t requests;

下面循环地分析已经放到请求队列里的下载请求。
#014 for (queue_t::iterator iter = mNetworkQueue.begin(); iter != mNetworkQueue.end(); )
#015 {
#016 queue_t::iterator curiter = iter++;

下面获取请求的工作对象。
#017 LLTextureFetchWorker* req = getWorker(*curiter);
#018 if (!req)
#019 {
#020 mNetworkQueue.erase(curiter);
#021 continue; // paranoia
#022 }
#023 if (req->mID == mDebugID)
#024 {
#025 mDebugCount++; // for setting breakpoints
#026 }

检查是否已经下载所有数据。
#027 if (req->mTotalPackets > 0 && req->mLastPacket >= req->mTotalPackets-1)
#028 {
#029 // We have all the packets... make sure this is high priority
#030 // req->setPriority(LLWorkerThread::PRIORITY_HIGH | req->mWorkPriority);
#031 continue;
#032 }
#033 F32 elapsed = req->mRequestedTimer.getElapsedTimeF32();
#034 F32 delta_priority = llabs(req->mRequestedPriority - req->mImagePriority);

按优先级和请求到达的时间来分类放到请求下载队列。
#035 if ((req->mSimRequestedDiscard != req->mDesiredDiscard) ||
#036 (delta_priority > MIN_DELTA_PRIORITY && elapsed >= MIN_REQUEST_TIME) ||
#037 (elapsed >= LAZY_FLUSH_TIMEOUT))
#038 {
#039 requests[req->mHost].insert(req);
#040 }
#041 }
#042
#043 std::string http_url;
#044 #if 0
#045 if (gSavedSettings.getBOOL("ImagePipelineUseHTTP"))
#046 {
#047 LLViewerRegion* region = gAgent.getRegion();
#048 if (region)
#049 {
#050 http_url = region->getCapability("RequestTextureDownload");
#051 }
#052 }
#053 #endif
#054

下面开始循环地发送纹理图片请求到服务器。
#055 for (work_request_map_t::iterator iter1 = requests.begin();
#056 iter1 != requests.end(); ++iter1)
#057 {
#058 bool use_http = http_url.empty() ? false : true;
#059 LLHost host = iter1->first;
#060 // invalid host = use agent host
#061 if (host == LLHost::invalid)
#062 {
#063 host = gAgent.getRegionHost();
#064 }
#065 else
#066 {
#067 use_http = false;
#068 }
#069
#070 if (use_http)
#071 {
#072 }
#073 else
#074 {

通过消息系统向服务器发送请求。
#075 S32 request_count = 0;
#076 for (request_list_t::iterator iter2 = iter1->second.begin();
#077 iter2 != iter1->second.end(); ++iter2)
#078 {

取得请求对象。
#079 LLTextureFetchWorker* req = *iter2;
#080 req->mSentRequest = LLTextureFetchWorker::SENT_SIM;

创建一个新的消息来发送请求。
#081 if (0 == request_count)
#082 {
#083 gMessageSystem->newMessageFast(_PREHASH_RequestImage);
#084 gMessageSystem->nextBlockFast(_PREHASH_AgentData);
#085 gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
#086 gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
#087 }
#088 S32 packet = req->mLastPacket + 1;

下面开始创始消息新块数据。
#089 gMessageSystem->nextBlockFast(_PREHASH_RequestImage);

添加图片ID到消息里。
#090 gMessageSystem->addUUIDFast(_PREHASH_Image, req->mID);
#091 gMessageSystem->addS8Fast(_PREHASH_DiscardLevel, (S8)req->mSimRequestedDiscard);
#092 gMessageSystem->addF32Fast(_PREHASH_DownloadPriority, req->mImagePriority);
#093 gMessageSystem->addU32Fast(_PREHASH_Packet, packet);
#094 gMessageSystem->addU8Fast(_PREHASH_Type, req->mType);
#095 // llinfos << "IMAGE REQUEST: " << req->mID << " Discard: " << req->mDesiredDiscard
#096 // << " Packet: " << packet << " Priority: " << req->mImagePriority << llendl;
#097
#098 req->lockWorkData();
#099 req->mSimRequestedDiscard = req->mDesiredDiscard;
#100 req->mRequestedPriority = req->mImagePriority;
#101 req->mRequestedTimer.reset();
#102 req->unlockWorkData();
#103 request_count++;
#104 if (request_count >= IMAGES_PER_REQUEST)
#105 {
#106 // llinfos << "REQUESTING " << request_count << " IMAGES FROM HOST: " << host.getIPString() << llendl;
#107 gMessageSystem->sendSemiReliable(host, NULL, NULL);
#108 request_count = 0;
#109 }
#110 }
#111 if (request_count > 0 && request_count < IMAGES_PER_REQUEST)
#112 {
#113 // llinfos << "REQUESTING " << request_count << " IMAGES FROM HOST: " << host.getIPString() << llendl;

通过消息系统发送纹理请求下载到服务器。
#114 gMessageSystem->sendSemiReliable(host, NULL, NULL);
#115 request_count = 0;
#116 }
#117 }
#118 }
#119

发送一些取消下载的纹理图片。
#120 // Send cancelations
#121 if (!mCancelQueue.empty())
#122 {
#123 for (cancel_queue_t::iterator iter1 = mCancelQueue.begin();
#124 iter1 != mCancelQueue.end(); ++iter1)
#125 {
#126 LLHost host = iter1->first;
#127 if (host == LLHost::invalid)
#128 {
#129 host = gAgent.getRegionHost();
#130 }
#131 S32 request_count = 0;
#132 for (queue_t::iterator iter2 = iter1->second.begin();
#133 iter2 != iter1->second.end(); ++iter2)
#134 {
#135 if (0 == request_count)
#136 {
#137 gMessageSystem->newMessageFast(_PREHASH_RequestImage);
#138 gMessageSystem->nextBlockFast(_PREHASH_AgentData);
#139 gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
#140 gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
#141 }
#142 gMessageSystem->nextBlockFast(_PREHASH_RequestImage);
#143 gMessageSystem->addUUIDFast(_PREHASH_Image, *iter2);
#144 gMessageSystem->addS8Fast(_PREHASH_DiscardLevel, -1);
#145 gMessageSystem->addF32Fast(_PREHASH_DownloadPriority, 0);
#146 gMessageSystem->addU32Fast(_PREHASH_Packet, 0);
#147 gMessageSystem->addU8Fast(_PREHASH_Type, 0);
#148 // llinfos << "CANCELING IMAGE REQUEST: " << (*iter2) << llendl;
#149
#150 request_count++;
#151 if (request_count >= IMAGES_PER_REQUEST)
#152 {
#153 gMessageSystem->sendSemiReliable(host, NULL, NULL);
#154 request_count = 0;
#155 }
#156 }
#157 if (request_count > 0 && request_count < IMAGES_PER_REQUEST)
#158 {
#159 gMessageSystem->sendSemiReliable(host, NULL, NULL);
#160 }
#161 }
#162 mCancelQueue.clear();
#163 }
#164 }

通过上面的代码，就可以清晰地看到怎么样把纹理的图片请求发送到服务器的，它是先把请求分类，主要按请求的时间和优先级来决定的。接着把这些需要下载的请求组成一个消息包，通过网络消息系统向服务器发送出去。在这里还处理了那些需要取消下载的纹理请求，由于下载比较大的纹理图片是非常耗费时间和带宽的，应该添加取消下载的功能，这是一个比较好的设计。





//蔡军生 2008/4/27 QQ:9073204 深圳