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

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

游戏引擎

开发平台：

C++ Builder

llviewerparcelmedia.cpp：源码内容
  1. /**
  2.  * @file llviewerparcelmedia.cpp
  3.  * @brief Handlers for multimedia on a per-parcel basis
  4.  *
  5.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2007-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"
  34. #include "llviewerparcelmedia.h"
  36. #include "llagent.h"
  37. #include "llaudioengine.h"
  38. #include "llviewercontrol.h"
  39. #include "llviewermedia.h"
  40. #include "llviewerregion.h"
  41. #include "llparcel.h"
  42. #include "llviewerparcelmgr.h"
  43. #include "lluuid.h"
  44. #include "message.h"
  45. #include "llviewermediafocus.h"
  46. #include "llviewerparcelmediaautoplay.h"
  47. #include "llnotificationsutil.h"
  48. //#include "llfirstuse.h"
  49. #include "llpluginclassmedia.h"
  50. #include "llviewertexture.h"
  52. // Static Variables
  54. S32 LLViewerParcelMedia::sMediaParcelLocalID = 0;
  55. LLUUID LLViewerParcelMedia::sMediaRegionID;
  56. viewer_media_t LLViewerParcelMedia::sMediaImpl;
  59. // static
  60. void LLViewerParcelMedia::initClass()
  61. {
  62. LLMessageSystem* msg = gMessageSystem;
  63. msg->setHandlerFunc("ParcelMediaCommandMessage", processParcelMediaCommandMessage );
  64. msg->setHandlerFunc("ParcelMediaUpdate", processParcelMediaUpdate );
  65. LLViewerParcelMediaAutoPlay::initClass();
  66. }
  68. //static 
  69. void LLViewerParcelMedia::cleanupClass()
  70. {
  71. // This needs to be destroyed before global destructor time.
  72. sMediaImpl = NULL;
  73. }
  75. //////////////////////////////////////////////////////////////////////////////////////////
  76. // static
  77. void LLViewerParcelMedia::update(LLParcel* parcel)
  78. {
  79. if (/*LLViewerMedia::hasMedia()*/ true)
  80. {
  81. // we have a player
  82. if (parcel)
  83. {
  84. if(!gAgent.getRegion())
  85. {
  86. sMediaRegionID = LLUUID() ;
  87. stop() ;
  88. LL_DEBUGS("Media") << "no agent region, bailing out." << LL_ENDL;
  89. return ;
  90. }
  92. // we're in a parcel
  93. bool new_parcel = false;
  94. S32 parcelid = parcel->getLocalID();
  96. LLUUID regionid = gAgent.getRegion()->getRegionID();
  97. if (parcelid != sMediaParcelLocalID || regionid != sMediaRegionID)
  98. {
  99. LL_DEBUGS("Media") << "New parcel, parcel id = " << parcelid << ", region id = " << regionid << LL_ENDL;
  100. sMediaParcelLocalID = parcelid;
  101. sMediaRegionID = regionid;
  102. new_parcel = true;
  103. }
  105. std::string mediaUrl = std::string ( parcel->getMediaURL () );
  106. std::string mediaCurrentUrl = std::string( parcel->getMediaCurrentURL());
  108. // if we have a current (link sharing) url, use it instead
  109. if (mediaCurrentUrl != "" && parcel->getMediaType() == "text/html")
  110. {
  111. mediaUrl = mediaCurrentUrl;
  112. }
  114. LLStringUtil::trim(mediaUrl);
  116. // If no parcel media is playing, nothing left to do
  117. if(sMediaImpl.isNull())
  119. {
  120. return;
  121. }
  123. // Media is playing...has something changed?
  124. else if (( sMediaImpl->getMediaURL() != mediaUrl )
  125. || ( sMediaImpl->getMediaTextureID() != parcel->getMediaID() )
  126. || ( sMediaImpl->getMimeType() != parcel->getMediaType() ))
  127. {
  128. // Only play if the media types are the same.
  129. if(sMediaImpl->getMimeType() == parcel->getMediaType())
  130. {
  131. play(parcel);
  132. }
  134. else
  135. {
  136. stop();
  137. }
  138. }
  139. }
  140. else
  141. {
  142. stop();
  143. }
  144. }
  145. /*
  146. else
  147. {
  148. // no audio player, do a first use dialog if there is media here
  149. if (parcel)
  150. {
  151. std::string mediaUrl = std::string ( parcel->getMediaURL () );
  152. if (!mediaUrl.empty ())
  153. {
  154. if (gWarningSettings.getBOOL("QuickTimeInstalled"))
  155. {
  156. gWarningSettings.setBOOL("QuickTimeInstalled", FALSE);
  158. LLNotificationsUtil::add("NoQuickTime" );
  159. };
  160. }
  161. }
  162. }
  163. */
  164. }
  166. // static
  167. void LLViewerParcelMedia::play(LLParcel* parcel)
  168. {
  169. lldebugs << "LLViewerParcelMedia::play" << llendl;
  171. if (!parcel) return;
  173. if (!gSavedSettings.getBOOL("AudioStreamingMedia"))
  174. return;
  176. std::string media_url = parcel->getMediaURL();
  177. std::string media_current_url = parcel->getMediaCurrentURL();
  178. std::string mime_type = parcel->getMediaType();
  179. LLUUID placeholder_texture_id = parcel->getMediaID();
  180. U8 media_auto_scale = parcel->getMediaAutoScale();
  181. U8 media_loop = parcel->getMediaLoop();
  182. S32 media_width = parcel->getMediaWidth();
  183. S32 media_height = parcel->getMediaHeight();
  185. if(sMediaImpl)
  186. {
  187. // If the url and mime type are the same, call play again
  188. if(sMediaImpl->getMediaURL() == media_url 
  189. && sMediaImpl->getMimeType() == mime_type
  190. && sMediaImpl->getMediaTextureID() == placeholder_texture_id)
  191. {
  192. LL_DEBUGS("Media") << "playing with existing url " << media_url << LL_ENDL;
  194. sMediaImpl->play();
  195. }
  196. // Else if the texture id's are the same, navigate and rediscover type
  197. // MBW -- This causes other state from the previous parcel (texture size, autoscale, and looping) to get re-used incorrectly.
  198. // It's also not really necessary -- just creating a new instance is fine.
  199. // else if(sMediaImpl->getMediaTextureID() == placeholder_texture_id)
  200. // {
  201. // sMediaImpl->navigateTo(media_url, mime_type, true);
  202. // }
  203. else
  204. {
  205. // Since the texture id is different, we need to generate a new impl
  207. // Delete the old one first so they don't fight over the texture.
  208. sMediaImpl = NULL;
  210. // A new impl will be created below.
  211. }
  212. }
  214. if(!sMediaImpl)
  215. {
  216. LL_DEBUGS("Media") << "new media impl with mime type " << mime_type << ", url " << media_url << LL_ENDL;
  218. // There is no media impl, make a new one
  219. sMediaImpl = LLViewerMedia::newMediaImpl(
  220. placeholder_texture_id,
  221. media_width, 
  222. media_height, 
  223. media_auto_scale,
  224. media_loop);
  225. sMediaImpl->setIsParcelMedia(true);
  226. sMediaImpl->navigateTo(media_url, mime_type, true);
  227. }
  229. //LLFirstUse::useMedia();
  231. LLViewerParcelMediaAutoPlay::playStarted();
  232. }
  234. // static
  235. void LLViewerParcelMedia::stop()
  236. {
  237. if(sMediaImpl.isNull())
  238. {
  239. return;
  240. }
  242. // We need to remove the media HUD if it is up.
  243. LLViewerMediaFocus::getInstance()->clearFocus();
  245. // This will unload & kill the media instance.
  246. sMediaImpl = NULL;
  247. }
  249. // static
  250. void LLViewerParcelMedia::pause()
  251. {
  252. if(sMediaImpl.isNull())
  253. {
  254. return;
  255. }
  256. sMediaImpl->pause();
  257. }
  259. // static
  260. void LLViewerParcelMedia::start()
  261. {
  262. if(sMediaImpl.isNull())
  263. {
  264. return;
  265. }
  266. sMediaImpl->start();
  268. //LLFirstUse::useMedia();
  270. LLViewerParcelMediaAutoPlay::playStarted();
  271. }
  273. // static
  274. void LLViewerParcelMedia::seek(F32 time)
  275. {
  276. if(sMediaImpl.isNull())
  277. {
  278. return;
  279. }
  280. sMediaImpl->seek(time);
  281. }
  283. // static
  284. void LLViewerParcelMedia::focus(bool focus)
  285. {
  286. sMediaImpl->focus(focus);
  287. }
  289. // static
  290. LLPluginClassMediaOwner::EMediaStatus LLViewerParcelMedia::getStatus()
  291. {
  292. LLPluginClassMediaOwner::EMediaStatus result = LLPluginClassMediaOwner::MEDIA_NONE;
  294. if(sMediaImpl.notNull() && sMediaImpl->hasMedia())
  295. {
  296. result = sMediaImpl->getMediaPlugin()->getStatus();
  297. }
  299. return result;
  300. }
  302. // static
  303. std::string LLViewerParcelMedia::getMimeType()
  304. {
  305. return sMediaImpl.notNull() ? sMediaImpl->getMimeType() : "none/none";
  306. }
  308. //static 
  309. std::string LLViewerParcelMedia::getURL()
  310. {
  311. std::string url;
  312. if(sMediaImpl.notNull())
  313. url = sMediaImpl->getMediaURL();
  315. if (url.empty())
  316. url = LLViewerParcelMgr::getInstance()->getAgentParcel()->getMediaCurrentURL();
  318. if (url.empty())
  319. url = LLViewerParcelMgr::getInstance()->getAgentParcel()->getMediaURL();
  321. return url;
  322. }
  324. //static 
  325. std::string LLViewerParcelMedia::getName()
  326. {
  327. if(sMediaImpl.notNull())
  328. return sMediaImpl->getName();
  329. return "";
  330. }
  332. viewer_media_t LLViewerParcelMedia::getParcelMedia()
  333. {
  334. return sMediaImpl;
  335. }
  337. //////////////////////////////////////////////////////////////////////////////////////////
  338. // static
  339. void LLViewerParcelMedia::processParcelMediaCommandMessage( LLMessageSystem *msg, void ** )
  340. {
  341. // extract the agent id
  342. // LLUUID agent_id;
  343. // msg->getUUID( agent_id );
  345. U32 flags;
  346. U32 command;
  347. F32 time;
  348. msg->getU32( "CommandBlock", "Flags", flags );
  349. msg->getU32( "CommandBlock", "Command", command);
  350. msg->getF32( "CommandBlock", "Time", time );
  352. if (flags &( (1<<PARCEL_MEDIA_COMMAND_STOP)
  353. | (1<<PARCEL_MEDIA_COMMAND_PAUSE)
  354. | (1<<PARCEL_MEDIA_COMMAND_PLAY)
  355. | (1<<PARCEL_MEDIA_COMMAND_LOOP)
  356. | (1<<PARCEL_MEDIA_COMMAND_UNLOAD) ))
  357. {
  358. // stop
  359. if( command == PARCEL_MEDIA_COMMAND_STOP )
  360. {
  361. stop();
  362. }
  363. else
  364. // pause
  365. if( command == PARCEL_MEDIA_COMMAND_PAUSE )
  366. {
  367. pause();
  368. }
  369. else
  370. // play
  371. if(( command == PARCEL_MEDIA_COMMAND_PLAY ) ||
  372.    ( command == PARCEL_MEDIA_COMMAND_LOOP ))
  373. {
  374. if (getStatus() == LLViewerMediaImpl::MEDIA_PAUSED)
  375. {
  376. start();
  377. }
  378. else
  379. {
  380. LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  381. play(parcel);
  382. }
  383. }
  384. else
  385. // unload
  386. if( command == PARCEL_MEDIA_COMMAND_UNLOAD )
  387. {
  388. stop();
  389. }
  390. }
  392. if (flags & (1<<PARCEL_MEDIA_COMMAND_TIME))
  393. {
  394. if(sMediaImpl.isNull())
  395. {
  396. LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  397. play(parcel);
  398. }
  399. seek(time);
  400. }
  401. }
  403. //////////////////////////////////////////////////////////////////////////////////////////
  404. // static
  405. void LLViewerParcelMedia::processParcelMediaUpdate( LLMessageSystem *msg, void ** )
  406. {
  407. LLUUID media_id;
  408. std::string media_url;
  409. std::string media_type;
  410. S32 media_width = 0;
  411. S32 media_height = 0;
  412. U8 media_auto_scale = FALSE;
  413. U8 media_loop = FALSE;
  415. msg->getUUID( "DataBlock", "MediaID", media_id );
  416. char media_url_buffer[257];
  417. msg->getString( "DataBlock", "MediaURL", 255, media_url_buffer );
  418. media_url = media_url_buffer;
  419. msg->getU8("DataBlock", "MediaAutoScale", media_auto_scale);
  421. if (msg->has("DataBlockExtended")) // do we have the extended data?
  422. {
  423. char media_type_buffer[257];
  424. msg->getString("DataBlockExtended", "MediaType", 255, media_type_buffer);
  425. media_type = media_type_buffer;
  426. msg->getU8("DataBlockExtended", "MediaLoop", media_loop);
  427. msg->getS32("DataBlockExtended", "MediaWidth", media_width);
  428. msg->getS32("DataBlockExtended", "MediaHeight", media_height);
  429. }
  431. LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
  432. BOOL same = FALSE;
  433. if (parcel)
  434. {
  435. same = ((parcel->getMediaURL() == media_url) &&
  436. (parcel->getMediaType() == media_type) &&
  437. (parcel->getMediaID() == media_id) &&
  438. (parcel->getMediaWidth() == media_width) &&
  439. (parcel->getMediaHeight() == media_height) &&
  440. (parcel->getMediaAutoScale() == media_auto_scale) &&
  441. (parcel->getMediaLoop() == media_loop));
  443. if (!same)
  444. {
  445. // temporarily store these new values in the parcel
  446. parcel->setMediaURL(media_url);
  447. parcel->setMediaType(media_type);
  448. parcel->setMediaID(media_id);
  449. parcel->setMediaWidth(media_width);
  450. parcel->setMediaHeight(media_height);
  451. parcel->setMediaAutoScale(media_auto_scale);
  452. parcel->setMediaLoop(media_loop);
  454. play(parcel);
  455. }
  456. }
  457. }
  458. // Static
  459. /////////////////////////////////////////////////////////////////////////////////////////
  460. void LLViewerParcelMedia::sendMediaNavigateMessage(const std::string& url)
  461. {
  462. std::string region_url = gAgent.getRegion()->getCapability("ParcelNavigateMedia");
  463. if (!region_url.empty())
  464. {
  465. // send navigate event to sim for link sharing
  466. LLSD body;
  467. body["agent-id"] = gAgent.getID();
  468. body["local-id"] = LLViewerParcelMgr::getInstance()->getAgentParcel()->getLocalID();
  469. body["url"] = url;
  470. LLHTTPClient::post(region_url, body, new LLHTTPClient::Responder);
  471. }
  472. else
  473. {
  474. llwarns << "can't get ParcelNavigateMedia capability" << llendl;
  475. }
  477. }
  479. /////////////////////////////////////////////////////////////////////////////////////////
  480. // inherited from LLViewerMediaObserver
  481. // virtual 
  482. void LLViewerParcelMedia::handleMediaEvent(LLPluginClassMedia* self, EMediaEvent event)
  483. {
  484. switch(event)
  485. {
  486. case MEDIA_EVENT_CONTENT_UPDATED:
  487. {
  488. // LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_CONTENT_UPDATED " << LL_ENDL;
  489. };
  490. break;
  492. case MEDIA_EVENT_TIME_DURATION_UPDATED:
  493. {
  494. // LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_TIME_DURATION_UPDATED, time is " << self->getCurrentTime() << " of " << self->getDuration() << LL_ENDL;
  495. };
  496. break;
  498. case MEDIA_EVENT_SIZE_CHANGED:
  499. {
  500. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_SIZE_CHANGED " << LL_ENDL;
  501. };
  502. break;
  504. case MEDIA_EVENT_CURSOR_CHANGED:
  505. {
  506. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_CURSOR_CHANGED, new cursor is " << self->getCursorName() << LL_ENDL;
  507. };
  508. break;
  510. case MEDIA_EVENT_NAVIGATE_BEGIN:
  511. {
  512. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_NAVIGATE_BEGIN " << LL_ENDL;
  513. };
  514. break;
  516. case MEDIA_EVENT_NAVIGATE_COMPLETE:
  517. {
  518. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_NAVIGATE_COMPLETE, result string is: " << self->getNavigateResultString() << LL_ENDL;
  519. };
  520. break;
  522. case MEDIA_EVENT_PROGRESS_UPDATED:
  523. {
  524. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_PROGRESS_UPDATED, loading at " << self->getProgressPercent() << "%" << LL_ENDL;
  525. };
  526. break;
  528. case MEDIA_EVENT_STATUS_TEXT_CHANGED:
  529. {
  530. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_STATUS_TEXT_CHANGED, new status text is: " << self->getStatusText() << LL_ENDL;
  531. };
  532. break;
  534. case MEDIA_EVENT_LOCATION_CHANGED:
  535. {
  536. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_LOCATION_CHANGED, new uri is: " << self->getLocation() << LL_ENDL;
  537. };
  538. break;
  540. case MEDIA_EVENT_CLICK_LINK_HREF:
  541. {
  542. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_CLICK_LINK_HREF, target is "" << self->getClickTarget() << "", uri is " << self->getClickURL() << LL_ENDL;
  543. };
  544. break;
  546. case MEDIA_EVENT_CLICK_LINK_NOFOLLOW:
  547. {
  548. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_CLICK_LINK_NOFOLLOW, uri is " << self->getClickURL() << LL_ENDL;
  549. };
  550. break;
  552. case MEDIA_EVENT_PLUGIN_FAILED:
  553. {
  554. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_PLUGIN_FAILED" << LL_ENDL;
  555. };
  556. break;
  558. case MEDIA_EVENT_PLUGIN_FAILED_LAUNCH:
  559. {
  560. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_PLUGIN_FAILED_LAUNCH" << LL_ENDL;
  561. };
  562. break;
  564. case MEDIA_EVENT_NAME_CHANGED:
  565. {
  566. LL_DEBUGS("Media") <<  "Media event:  MEDIA_EVENT_NAME_CHANGED" << LL_ENDL;
  567. };
  568. break;
  569. };
  570. }
  572. // TODO: observer
  573. /*
  574. void LLViewerParcelMediaNavigationObserver::onNavigateComplete( const EventType& event_in )
  575. {
  576. std::string url = event_in.getStringValue();
  578. if (mCurrentURL != url && ! mFromMessage)
  579. {
  580. LLViewerParcelMedia::sendMediaNavigateMessage(url);
  581. }
  583. mCurrentURL = url;
  584. mFromMessage = false;
  586. }
  587. */