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

我不是女神ヾ 2022-08-27 01:24 122阅读 0赞

这里接着上一次获取纹理图片线程，继续分析发送纹理图片请求到服务器。代码如下：

\#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 \}

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

![o_Snapshot_040.JPG][]

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

[o_Snapshot_040.JPG]: /images/20220824/f06f592365bb4067b82a9d04a97e111d.png