4067 lines
119 KiB
C++
4067 lines
119 KiB
C++
/**
|
|
* @file llviewermedia.cpp
|
|
* @brief Client interface to the media engine
|
|
*
|
|
* $LicenseInfo:firstyear=2007&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2007-2009, Linden Research, Inc.
|
|
*
|
|
* Second Life Viewer Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in doc/GPL-license.txt in this distribution, or
|
|
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file doc/FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
|
|
#include "llviewermedia.h"
|
|
|
|
|
|
#include "llviewermedia.h"
|
|
|
|
#include "llagent.h"
|
|
#include "llagentcamera.h"
|
|
#include "llappviewer.h"
|
|
#include "llaudioengine.h" // for gAudiop
|
|
#include "llcallbacklist.h"
|
|
#include "lldir.h"
|
|
#include "lldiriterator.h"
|
|
#include "llevent.h" // LLSimpleListener
|
|
#include "llfloaterwebcontent.h" // for handling window close requests and geometry change requests in media browser windows.
|
|
#include "llfocusmgr.h"
|
|
#include "llhttpclient.h"
|
|
#include "llkeyboard.h"
|
|
#include "llmarketplacefunctions.h"
|
|
#include "llmediaentry.h"
|
|
#include "llmenugl.h"
|
|
#include "llmimetypes.h"
|
|
#include "llmutelist.h"
|
|
#include "llnotifications.h"
|
|
#include "llnotificationsutil.h"
|
|
#include "llpanelprofile.h"
|
|
#include "llparcel.h"
|
|
#include "llpluginclassmedia.h"
|
|
#include "llplugincookiestore.h"
|
|
#include "llurldispatcher.h"
|
|
#include "lluuid.h"
|
|
#include "llvieweraudio.h"
|
|
#include "llviewermediafocus.h"
|
|
#include "llviewercontrol.h"
|
|
#include "llviewernetwork.h"
|
|
#include "llviewerparcelmedia.h"
|
|
#include "llviewerparcelmgr.h"
|
|
#include "llviewerregion.h"
|
|
#include "llviewertexture.h"
|
|
#include "llviewertexturelist.h"
|
|
#include "llviewerwindow.h"
|
|
#include "llvoavatar.h"
|
|
#include "llvoavatarself.h"
|
|
#include "llvovolume.h"
|
|
#include "llwebprofile.h"
|
|
#include "llwindow.h"
|
|
#include "llvieweraudio.h"
|
|
|
|
#include "aifilepicker.h"
|
|
#include "llstartup.h"
|
|
|
|
#include <boost/bind.hpp> // for SkinFolder listener
|
|
#include <boost/signals2.hpp>
|
|
|
|
std::string getProfileURL(const std::string& agent_name);
|
|
|
|
/*static*/ const char* LLViewerMedia::AUTO_PLAY_MEDIA_SETTING = "ParcelMediaAutoPlayEnable";
|
|
/*static*/ const char* LLViewerMedia::AUTO_PLAY_PRIM_MEDIA_SETTING = "PrimMediaAutoPlayEnable";
|
|
/*static*/ const char* LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING = "MediaShowOnOthers";
|
|
/*static*/ const char* LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING = "MediaShowWithinParcel";
|
|
/*static*/ const char* LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING = "MediaShowOutsideParcel";
|
|
|
|
|
|
// Move this to its own file.
|
|
|
|
LLViewerMediaEventEmitter::~LLViewerMediaEventEmitter()
|
|
{
|
|
observerListType::iterator iter = mObservers.begin();
|
|
|
|
while( iter != mObservers.end() )
|
|
{
|
|
LLViewerMediaObserver *self = *iter;
|
|
iter++;
|
|
remObserver(self);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
bool LLViewerMediaEventEmitter::addObserver( LLViewerMediaObserver* observer )
|
|
{
|
|
if ( ! observer )
|
|
return false;
|
|
|
|
if ( std::find( mObservers.begin(), mObservers.end(), observer ) != mObservers.end() )
|
|
return false;
|
|
|
|
mObservers.push_back( observer );
|
|
observer->mEmitters.push_back( this );
|
|
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
bool LLViewerMediaEventEmitter::remObserver( LLViewerMediaObserver* observer )
|
|
{
|
|
if ( ! observer )
|
|
return false;
|
|
|
|
mObservers.remove( observer );
|
|
observer->mEmitters.remove(this);
|
|
|
|
return true;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
void LLViewerMediaEventEmitter::emitEvent( LLPluginClassMedia* media, LLViewerMediaObserver::EMediaEvent event )
|
|
{
|
|
// Broadcast the event to any observers.
|
|
observerListType::iterator iter = mObservers.begin();
|
|
while( iter != mObservers.end() )
|
|
{
|
|
LLViewerMediaObserver *self = *iter;
|
|
++iter;
|
|
self->handleMediaEvent( media, event );
|
|
}
|
|
}
|
|
|
|
// Move this to its own file.
|
|
LLViewerMediaObserver::~LLViewerMediaObserver()
|
|
{
|
|
std::list<LLViewerMediaEventEmitter *>::iterator iter = mEmitters.begin();
|
|
|
|
while( iter != mEmitters.end() )
|
|
{
|
|
LLViewerMediaEventEmitter *self = *iter;
|
|
iter++;
|
|
self->remObserver( this );
|
|
}
|
|
}
|
|
|
|
|
|
// Move this to its own file.
|
|
// helper class that tries to download a URL from a web site and calls a method
|
|
// on the Panel Land Media and to discover the MIME type
|
|
class LLMimeDiscoveryResponder : public LLHTTPClient::ResponderHeadersOnly
|
|
{
|
|
LOG_CLASS(LLMimeDiscoveryResponder);
|
|
public:
|
|
LLMimeDiscoveryResponder( viewer_media_t media_impl)
|
|
: mMediaImpl(media_impl),
|
|
mInitialized(false)
|
|
{
|
|
if(mMediaImpl->mMimeTypeProbe != NULL)
|
|
{
|
|
LL_ERRS() << "impl already has an outstanding responder" << LL_ENDL;
|
|
}
|
|
|
|
mMediaImpl->mMimeTypeProbe = this;
|
|
}
|
|
|
|
~LLMimeDiscoveryResponder()
|
|
{
|
|
disconnectOwner();
|
|
}
|
|
|
|
private:
|
|
/* virtual */ void completedHeaders()
|
|
{
|
|
if (!isGoodStatus(mStatus))
|
|
{
|
|
LL_WARNS() << dumpResponse()
|
|
<< " [headers:" << getResponseHeaders() << "]" << LL_ENDL;
|
|
}
|
|
std::string media_type;
|
|
std::string::size_type idx1 = media_type.find_first_of(";");
|
|
std::string mime_type = media_type.substr(0, idx1);
|
|
|
|
LL_DEBUGS() << "status is " << getStatus() << ", media type \"" << media_type << "\"" << LL_ENDL;
|
|
|
|
// 2xx status codes indicate success.
|
|
// Most 4xx status codes are successful enough for our purposes.
|
|
// 499 is the error code for host not found, timeout, etc.
|
|
// 500 means "Internal Server error" but we decided it's okay to
|
|
// accept this and go past it in the MIME type probe
|
|
// 302 means the resource can be found temporarily in a different place - added this for join.secondlife.com
|
|
// 499 is a code specifc to join.secondlife.com apparently safe to ignore
|
|
// if( ((status >= 200) && (status < 300)) ||
|
|
// ((status >= 400) && (status < 499)) ||
|
|
// (status == 500) ||
|
|
// (status == 302) ||
|
|
// (status == 499)
|
|
// )
|
|
// We now no longer check the error code returned from the probe.
|
|
// If we have a mime type, use it. If not, default to the web plugin and let it handle error reporting.
|
|
//if(1)
|
|
{
|
|
// The probe was successful.
|
|
if(mime_type.empty())
|
|
{
|
|
// Some sites don't return any content-type header at all.
|
|
// Treat an empty mime type as text/html.
|
|
mime_type = "text/html";
|
|
}
|
|
}
|
|
//else
|
|
//{
|
|
// LL_WARNS() << "responder failed with status " << dumpResponse() << LL_ENDL;
|
|
//
|
|
// if(mMediaImpl)
|
|
// {
|
|
// mMediaImpl->mMediaSourceFailed = true;
|
|
// }
|
|
// return;
|
|
//}
|
|
|
|
// the call to initializeMedia may disconnect the responder, which will clear mMediaImpl.
|
|
// Make a local copy so we can call loadURI() afterwards.
|
|
LLViewerMediaImpl *impl = mMediaImpl;
|
|
|
|
if(impl && !mInitialized && ! mime_type.empty())
|
|
{
|
|
if(impl->initializeMedia(mime_type))
|
|
{
|
|
mInitialized = true;
|
|
impl->loadURI();
|
|
disconnectOwner();
|
|
}
|
|
}
|
|
}
|
|
|
|
public:
|
|
/*virtual*/ char const* getName(void) const { return "LLMimeDiscoveryResponder"; }
|
|
void cancelRequest()
|
|
{
|
|
disconnectOwner();
|
|
}
|
|
|
|
private:
|
|
void disconnectOwner()
|
|
{
|
|
if(mMediaImpl)
|
|
{
|
|
if(mMediaImpl->mMimeTypeProbe != this)
|
|
{
|
|
LL_ERRS() << "internal error: mMediaImpl->mMimeTypeProbe != this" << LL_ENDL;
|
|
}
|
|
|
|
mMediaImpl->mMimeTypeProbe = NULL;
|
|
}
|
|
mMediaImpl = NULL;
|
|
}
|
|
|
|
|
|
public:
|
|
LLViewerMediaImpl *mMediaImpl;
|
|
bool mInitialized;
|
|
};
|
|
|
|
class LLViewerMediaOpenIDResponder : public LLHTTPClient::ResponderWithCompleted
|
|
{
|
|
LOG_CLASS(LLViewerMediaOpenIDResponder);
|
|
public:
|
|
LLViewerMediaOpenIDResponder( )
|
|
{
|
|
}
|
|
|
|
~LLViewerMediaOpenIDResponder()
|
|
{
|
|
}
|
|
|
|
/* virtual */ void completedRaw(
|
|
const LLChannelDescriptors& channels,
|
|
const LLIOPipe::buffer_ptr_t& buffer)
|
|
{
|
|
// We don't care about the content of the response, only the Set-Cookie header.
|
|
LL_DEBUGS("MediaAuth") << dumpResponse()
|
|
<< " [headers:" << getResponseHeaders() << "]" << LL_ENDL;
|
|
std::string cookie;
|
|
getResponseHeaders().getFirstValue("set-cookie", cookie);
|
|
|
|
// *TODO: What about bad status codes? Does this destroy previous cookies?
|
|
LLViewerMedia::openIDCookieResponse(cookie);
|
|
}
|
|
|
|
/*virtual*/ char const* getName(void) const { return "LLViewerMediaOpenIDResponder"; }
|
|
/*virtual*/ bool needsHeaders(void) const { return true; }
|
|
};
|
|
|
|
class LLViewerMediaWebProfileResponder : public LLHTTPClient::ResponderWithCompleted
|
|
{
|
|
LOG_CLASS(LLViewerMediaWebProfileResponder);
|
|
public:
|
|
LLViewerMediaWebProfileResponder(std::string host)
|
|
{
|
|
mHost = host;
|
|
}
|
|
|
|
~LLViewerMediaWebProfileResponder()
|
|
{
|
|
}
|
|
|
|
void completedRaw(
|
|
const LLChannelDescriptors& channels,
|
|
const LLIOPipe::buffer_ptr_t& buffer)
|
|
{
|
|
// We don't care about the content of the response, only the set-cookie header.
|
|
LL_WARNS("MediaAuth") << dumpResponse()
|
|
<< " [headers:" << getResponseHeaders() << "]" << LL_ENDL;
|
|
|
|
AIHTTPReceivedHeaders stripped_content = getResponseHeaders();
|
|
LL_WARNS("MediaAuth") << stripped_content << LL_ENDL;
|
|
|
|
AIHTTPReceivedHeaders::range_type cookies;
|
|
if (mReceivedHeaders.getValues("set-cookie", cookies))
|
|
{
|
|
for (AIHTTPReceivedHeaders::iterator_type cookie = cookies.first; cookie != cookies.second; ++cookie)
|
|
{
|
|
// *TODO: What about bad status codes? Does this destroy previous cookies?
|
|
LLViewerMedia::getCookieStore()->setCookiesFromHost(cookie->second, mHost);
|
|
|
|
if (cookie->second.substr(0, cookie->second.find('=')) == "_my_secondlife_session")
|
|
{
|
|
// Set cookie for snapshot publishing.
|
|
std::string auth_cookie = cookie->second.substr(0, cookie->second.find(";")); // strip path
|
|
LLWebProfile::setAuthCookie(auth_cookie);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*virtual*/ char const* getName() const { return "LLViewerMediaWebProfileResponder"; }
|
|
/*virtual*/ bool needsHeaders() const { return true; }
|
|
|
|
std::string mHost;
|
|
};
|
|
|
|
|
|
LLPluginCookieStore *LLViewerMedia::sCookieStore = NULL;
|
|
LLURL LLViewerMedia::sOpenIDURL;
|
|
std::string LLViewerMedia::sOpenIDCookie;
|
|
LLPluginClassMedia* LLViewerMedia::sSpareBrowserMediaSource = NULL;
|
|
static LLViewerMedia::impl_list sViewerMediaImplList;
|
|
static LLViewerMedia::impl_id_map sViewerMediaTextureIDMap;
|
|
static LLTimer sMediaCreateTimer;
|
|
static const F32 LLVIEWERMEDIA_CREATE_DELAY = 1.0f;
|
|
static F32 sGlobalVolume = 1.0f;
|
|
static bool sForceUpdate = false;
|
|
static LLUUID sOnlyAudibleTextureID = LLUUID::null;
|
|
static F64 sLowestLoadableImplInterest = 0.0f;
|
|
static bool sAnyMediaShowing = false;
|
|
static boost::signals2::connection sTeleportFinishConnection;
|
|
static std::string sUpdatedCookies;
|
|
static const char *PLUGIN_COOKIE_FILE_NAME = "plugin_cookies.txt";
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
static void add_media_impl(LLViewerMediaImpl* media)
|
|
{
|
|
sViewerMediaImplList.push_back(media);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
static void remove_media_impl(LLViewerMediaImpl* media)
|
|
{
|
|
LLViewerMedia::impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
LLViewerMedia::impl_list::iterator end = sViewerMediaImplList.end();
|
|
|
|
for(; iter != end; iter++)
|
|
{
|
|
if(media == *iter)
|
|
{
|
|
sViewerMediaImplList.erase(iter);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
class LLViewerMediaMuteListObserver : public LLMuteListObserver
|
|
{
|
|
/* virtual */ void onChange() { LLViewerMedia::muteListChanged();}
|
|
};
|
|
|
|
static LLViewerMediaMuteListObserver sViewerMediaMuteListObserver;
|
|
static bool sViewerMediaMuteListObserverInitialized = false;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// LLViewerMedia
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
viewer_media_t LLViewerMedia::newMediaImpl(
|
|
const LLUUID& texture_id,
|
|
S32 media_width,
|
|
S32 media_height,
|
|
U8 media_auto_scale,
|
|
U8 media_loop)
|
|
{
|
|
LLViewerMediaImpl* media_impl = getMediaImplFromTextureID(texture_id);
|
|
if(media_impl == NULL || texture_id.isNull())
|
|
{
|
|
// Create the media impl
|
|
media_impl = new LLViewerMediaImpl(texture_id, media_width, media_height, media_auto_scale, media_loop);
|
|
}
|
|
else
|
|
{
|
|
media_impl->unload();
|
|
media_impl->setTextureID(texture_id);
|
|
media_impl->mMediaWidth = media_width;
|
|
media_impl->mMediaHeight = media_height;
|
|
media_impl->mMediaAutoScale = media_auto_scale;
|
|
media_impl->mMediaLoop = media_loop;
|
|
}
|
|
|
|
return media_impl;
|
|
}
|
|
|
|
viewer_media_t LLViewerMedia::updateMediaImpl(LLMediaEntry* media_entry, const std::string& previous_url, bool update_from_self)
|
|
{
|
|
// Try to find media with the same media ID
|
|
viewer_media_t media_impl = getMediaImplFromTextureID(media_entry->getMediaID());
|
|
|
|
LL_DEBUGS() << "called, current URL is \"" << media_entry->getCurrentURL()
|
|
<< "\", previous URL is \"" << previous_url
|
|
<< "\", update_from_self is " << (update_from_self?"true":"false")
|
|
<< LL_ENDL;
|
|
|
|
bool was_loaded = false;
|
|
bool needs_navigate = false;
|
|
|
|
if(media_impl)
|
|
{
|
|
was_loaded = media_impl->hasMedia();
|
|
|
|
media_impl->setHomeURL(media_entry->getHomeURL());
|
|
|
|
media_impl->mMediaAutoScale = media_entry->getAutoScale();
|
|
media_impl->mMediaLoop = media_entry->getAutoLoop();
|
|
media_impl->mMediaWidth = media_entry->getWidthPixels();
|
|
media_impl->mMediaHeight = media_entry->getHeightPixels();
|
|
media_impl->mMediaAutoPlay = media_entry->getAutoPlay();
|
|
media_impl->mMediaEntryURL = media_entry->getCurrentURL();
|
|
LLPluginClassMedia* plugin = media_impl->getMediaPlugin();
|
|
if (plugin)
|
|
{
|
|
plugin->setAutoScale(media_impl->mMediaAutoScale);
|
|
plugin->setLoop(media_impl->mMediaLoop);
|
|
plugin->setSize(media_entry->getWidthPixels(), media_entry->getHeightPixels());
|
|
}
|
|
|
|
bool url_changed = (media_impl->mMediaEntryURL != previous_url);
|
|
if(media_impl->mMediaEntryURL.empty())
|
|
{
|
|
if(url_changed)
|
|
{
|
|
// The current media URL is now empty. Unload the media source.
|
|
media_impl->unload();
|
|
|
|
LL_DEBUGS() << "Unloading media instance (new current URL is empty)." << LL_ENDL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The current media URL is not empty.
|
|
// If (the media was already loaded OR the media was set to autoplay) AND this update didn't come from this agent,
|
|
// do a navigate.
|
|
bool auto_play = media_impl->isAutoPlayable();
|
|
if((was_loaded || auto_play) && !update_from_self)
|
|
{
|
|
needs_navigate = url_changed;
|
|
}
|
|
|
|
LL_DEBUGS() << "was_loaded is " << (was_loaded?"true":"false")
|
|
<< ", auto_play is " << (auto_play?"true":"false")
|
|
<< ", needs_navigate is " << (needs_navigate?"true":"false") << LL_ENDL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
media_impl = newMediaImpl(
|
|
media_entry->getMediaID(),
|
|
media_entry->getWidthPixels(),
|
|
media_entry->getHeightPixels(),
|
|
media_entry->getAutoScale(),
|
|
media_entry->getAutoLoop());
|
|
|
|
media_impl->setHomeURL(media_entry->getHomeURL());
|
|
media_impl->mMediaAutoPlay = media_entry->getAutoPlay();
|
|
media_impl->mMediaEntryURL = media_entry->getCurrentURL();
|
|
if(media_impl->isAutoPlayable())
|
|
{
|
|
needs_navigate = true;
|
|
}
|
|
}
|
|
|
|
if(media_impl)
|
|
{
|
|
if(needs_navigate)
|
|
{
|
|
media_impl->navigateTo(media_impl->mMediaEntryURL, "", true, true);
|
|
LL_DEBUGS() << "navigating to URL " << media_impl->mMediaEntryURL << LL_ENDL;
|
|
}
|
|
else if(!media_impl->mMediaURL.empty() && (media_impl->mMediaURL != media_impl->mMediaEntryURL))
|
|
{
|
|
// If we already have a non-empty media URL set and we aren't doing a navigate, update the media URL to match the media entry.
|
|
media_impl->mMediaURL = media_impl->mMediaEntryURL;
|
|
|
|
// If this causes a navigate at some point (such as after a reload), it should be considered server-driven so it isn't broadcast.
|
|
media_impl->mNavigateServerRequest = true;
|
|
|
|
LL_DEBUGS() << "updating URL in the media impl to " << media_impl->mMediaEntryURL << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
return media_impl;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
LLViewerMediaImpl* LLViewerMedia::getMediaImplFromTextureID(const LLUUID& texture_id)
|
|
{
|
|
LLViewerMediaImpl* result = NULL;
|
|
|
|
// Look up the texture ID in the texture id->impl map.
|
|
impl_id_map::iterator iter = sViewerMediaTextureIDMap.find(texture_id);
|
|
if(iter != sViewerMediaTextureIDMap.end())
|
|
{
|
|
result = iter->second;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
std::string LLViewerMedia::getCurrentUserAgent()
|
|
{
|
|
// Don't include version, channel, or skin -- MC
|
|
|
|
// Don't use user-visible string to avoid
|
|
// punctuation and strange characters.
|
|
//std::string skin_name = gSavedSettings.getString("SkinCurrent");
|
|
|
|
// Just in case we need to check browser differences in A/B test
|
|
// builds.
|
|
//std::string channel = gSavedSettings.getString("VersionChannelName");
|
|
|
|
// append our magic version number string to the browser user agent id
|
|
// See the HTTP 1.0 and 1.1 specifications for allowed formats:
|
|
// http://www.ietf.org/rfc/rfc1945.txt section 10.15
|
|
// http://www.ietf.org/rfc/rfc2068.txt section 3.8
|
|
// This was also helpful:
|
|
// http://www.mozilla.org/build/revised-user-agent-strings.html
|
|
std::ostringstream codec;
|
|
codec << "SecondLife/";
|
|
codec << "C64 Basic V2";
|
|
//codec << ViewerVersion::getImpMajorVersion() << "." << ViewerVersion::getImpMinorVersion() << "." << ViewerVersion::getImpPatchVersion() << " " << ViewerVersion::getImpTestVersion();
|
|
//codec << " (" << channel << "; " << skin_name << " skin)";
|
|
// LL_INFOS() << codec.str() << LL_ENDL;
|
|
|
|
return codec.str();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::updateBrowserUserAgent()
|
|
{
|
|
std::string user_agent = getCurrentUserAgent();
|
|
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
|
|
for(; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
LLPluginClassMedia* plugin = pimpl->getMediaPlugin();
|
|
if(plugin && plugin->pluginSupportsMediaBrowser())
|
|
{
|
|
plugin->setBrowserUserAgent(user_agent);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
bool LLViewerMedia::handleSkinCurrentChanged(const LLSD& /*newvalue*/)
|
|
{
|
|
// gSavedSettings is already updated when this function is called.
|
|
updateBrowserUserAgent();
|
|
return true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
bool LLViewerMedia::textureHasMedia(const LLUUID& texture_id)
|
|
{
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
|
|
for(; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
if(pimpl->getMediaTextureID() == texture_id)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::setVolume(F32 volume)
|
|
{
|
|
if(volume != sGlobalVolume || sForceUpdate)
|
|
{
|
|
sGlobalVolume = volume;
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
|
|
for(; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
pimpl->updateVolume();
|
|
}
|
|
|
|
sForceUpdate = false;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
F32 LLViewerMedia::getVolume()
|
|
{
|
|
return sGlobalVolume;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::muteListChanged()
|
|
{
|
|
// When the mute list changes, we need to check mute status on all impls.
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
|
|
for(; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
pimpl->mNeedsMuteCheck = true;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
bool LLViewerMedia::isInterestingEnough(const LLVOVolume *object, const F64 &object_interest)
|
|
{
|
|
bool result = false;
|
|
|
|
if (NULL == object)
|
|
{
|
|
result = false;
|
|
}
|
|
// Focused? Then it is interesting!
|
|
else if (LLViewerMediaFocus::getInstance()->getFocusedObjectID() == object->getID())
|
|
{
|
|
result = true;
|
|
}
|
|
// Selected? Then it is interesting!
|
|
// XXX Sadly, 'contains()' doesn't take a const :(
|
|
else if (LLSelectMgr::getInstance()->getSelection()->contains(const_cast<LLVOVolume*>(object)))
|
|
{
|
|
result = true;
|
|
}
|
|
else
|
|
{
|
|
LL_DEBUGS() << "object interest = " << object_interest << ", lowest loadable = " << sLowestLoadableImplInterest << LL_ENDL;
|
|
if(object_interest >= sLowestLoadableImplInterest)
|
|
result = true;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
LLViewerMedia::impl_list &LLViewerMedia::getPriorityList()
|
|
{
|
|
return sViewerMediaImplList;
|
|
}
|
|
|
|
// This is the predicate function used to sort sViewerMediaImplList by priority.
|
|
bool LLViewerMedia::priorityComparitor(const LLViewerMediaImpl* i1, const LLViewerMediaImpl* i2)
|
|
{
|
|
if(i1->isForcedUnloaded() && !i2->isForcedUnloaded())
|
|
{
|
|
// Muted or failed items always go to the end of the list, period.
|
|
return false;
|
|
}
|
|
else if(i2->isForcedUnloaded() && !i1->isForcedUnloaded())
|
|
{
|
|
// Muted or failed items always go to the end of the list, period.
|
|
return true;
|
|
}
|
|
else if(i1->hasFocus())
|
|
{
|
|
// The item with user focus always comes to the front of the list, period.
|
|
return true;
|
|
}
|
|
else if(i2->hasFocus())
|
|
{
|
|
// The item with user focus always comes to the front of the list, period.
|
|
return false;
|
|
}
|
|
else if(i1->isParcelMedia())
|
|
{
|
|
// The parcel media impl sorts above all other inworld media, unless one has focus.
|
|
return true;
|
|
}
|
|
else if(i2->isParcelMedia())
|
|
{
|
|
// The parcel media impl sorts above all other inworld media, unless one has focus.
|
|
return false;
|
|
}
|
|
else if(i1->getUsedInUI() && !i2->getUsedInUI())
|
|
{
|
|
// i1 is a UI element, i2 is not. This makes i1 "less than" i2, so it sorts earlier in our list.
|
|
return true;
|
|
}
|
|
else if(i2->getUsedInUI() && !i1->getUsedInUI())
|
|
{
|
|
// i2 is a UI element, i1 is not. This makes i2 "less than" i1, so it sorts earlier in our list.
|
|
return false;
|
|
}
|
|
else if(i1->isPlayable() && !i2->isPlayable())
|
|
{
|
|
// Playable items sort above ones that wouldn't play even if they got high enough priority
|
|
return true;
|
|
}
|
|
else if(!i1->isPlayable() && i2->isPlayable())
|
|
{
|
|
// Playable items sort above ones that wouldn't play even if they got high enough priority
|
|
return false;
|
|
}
|
|
else if(i1->getInterest() == i2->getInterest())
|
|
{
|
|
// Generally this will mean both objects have zero interest. In this case, sort on distance.
|
|
return (i1->getProximityDistance() < i2->getProximityDistance());
|
|
}
|
|
else
|
|
{
|
|
// The object with the larger interest value should be earlier in the list, so we reverse the sense of the comparison here.
|
|
return (i1->getInterest() > i2->getInterest());
|
|
}
|
|
}
|
|
|
|
static bool proximity_comparitor(const LLViewerMediaImpl* i1, const LLViewerMediaImpl* i2)
|
|
{
|
|
if(i1->getProximityDistance() < i2->getProximityDistance())
|
|
{
|
|
return true;
|
|
}
|
|
else if(i1->getProximityDistance() > i2->getProximityDistance())
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// Both objects have the same distance. This most likely means they're two faces of the same object.
|
|
// They may also be faces on different objects with exactly the same distance (like HUD objects).
|
|
// We don't actually care what the sort order is for this case, as long as it's stable and doesn't change when you enable/disable media.
|
|
// Comparing the impl pointers gives a completely arbitrary ordering, but it will be stable.
|
|
return (i1 < i2);
|
|
}
|
|
}
|
|
|
|
static LLFastTimer::DeclareTimer FTM_MEDIA_UPDATE("Update Media");
|
|
static LLFastTimer::DeclareTimer FTM_MEDIA_SPARE_IDLE("Spare Idle");
|
|
static LLFastTimer::DeclareTimer FTM_MEDIA_UPDATE_INTEREST("Update/Interest");
|
|
static LLFastTimer::DeclareTimer FTM_MEDIA_SORT("Sort");
|
|
static LLFastTimer::DeclareTimer FTM_MEDIA_SORT2("Sort 2");
|
|
static LLFastTimer::DeclareTimer FTM_MEDIA_MISC("Misc");
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::updateMedia(void *dummy_arg)
|
|
{
|
|
LLFastTimer t1(FTM_MEDIA_UPDATE);
|
|
|
|
// Enable/disable the plugin read thread
|
|
static LLCachedControl<bool> pluginUseReadThread(gSavedSettings, "PluginUseReadThread");
|
|
LLPluginProcessParent::setUseReadThread(pluginUseReadThread);
|
|
|
|
// HACK: we always try to keep a spare running webkit plugin around to improve launch times.
|
|
createSpareBrowserMediaSource();
|
|
|
|
sAnyMediaShowing = false;
|
|
sUpdatedCookies = getCookieStore()->getChangedCookies();
|
|
if(!sUpdatedCookies.empty())
|
|
{
|
|
LL_DEBUGS() << "updated cookies will be sent to all loaded plugins: " << LL_ENDL;
|
|
LL_DEBUGS() << sUpdatedCookies << LL_ENDL;
|
|
}
|
|
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
|
|
{
|
|
LLFastTimer t(FTM_MEDIA_UPDATE_INTEREST);
|
|
for(; iter != end;)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter++;
|
|
pimpl->update();
|
|
pimpl->calculateInterest();
|
|
}
|
|
}
|
|
|
|
// Let the spare media source actually launch
|
|
if(sSpareBrowserMediaSource)
|
|
{
|
|
LLFastTimer t(FTM_MEDIA_SPARE_IDLE);
|
|
sSpareBrowserMediaSource->idle();
|
|
}
|
|
|
|
{
|
|
LLFastTimer t(FTM_MEDIA_SORT);
|
|
// Sort the static instance list using our interest criteria
|
|
sViewerMediaImplList.sort(priorityComparitor);
|
|
}
|
|
|
|
// Go through the list again and adjust according to priority.
|
|
iter = sViewerMediaImplList.begin();
|
|
end = sViewerMediaImplList.end();
|
|
|
|
F64 total_cpu = 0.0f;
|
|
int impl_count_total = 0;
|
|
int impl_count_interest_low = 0;
|
|
int impl_count_interest_normal = 0;
|
|
|
|
std::vector<LLViewerMediaImpl*> proximity_order;
|
|
|
|
static LLCachedControl<bool> inworld_media_enabled(gSavedSettings, "AudioStreamingMedia");
|
|
static LLCachedControl<bool> inworld_audio_enabled(gSavedSettings, "AudioStreamingMusic");
|
|
static LLCachedControl<U32> max_instances(gSavedSettings, "PluginInstancesTotal");
|
|
static LLCachedControl<U32> max_normal(gSavedSettings, "PluginInstancesNormal");
|
|
static LLCachedControl<U32> max_low(gSavedSettings, "PluginInstancesLow");
|
|
static LLCachedControl<F32> max_cpu(gSavedSettings, "PluginInstancesCPULimit");
|
|
// Setting max_cpu to 0.0 disables CPU usage checking.
|
|
bool check_cpu_usage = (max_cpu != 0.0f);
|
|
|
|
LLViewerMediaImpl* lowest_interest_loadable = NULL;
|
|
|
|
// Notes on tweakable params:
|
|
// max_instances must be set high enough to allow the various instances used in the UI (for the help browser, search, etc.) to be loaded.
|
|
// If max_normal + max_low is less than max_instances, things will tend to get unloaded instead of being set to slideshow.
|
|
|
|
{
|
|
LLFastTimer t(FTM_MEDIA_MISC);
|
|
for(; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
|
|
LLViewerMediaImpl::EPriority new_priority = LLViewerMediaImpl::PRIORITY_NORMAL;
|
|
|
|
if(pimpl->isForcedUnloaded() || (impl_count_total >= (int)max_instances))
|
|
{
|
|
// Never load muted or failed impls.
|
|
// Hard limit on the number of instances that will be loaded at one time
|
|
new_priority = LLViewerMediaImpl::PRIORITY_UNLOADED;
|
|
}
|
|
else if(!pimpl->getVisible())
|
|
{
|
|
new_priority = LLViewerMediaImpl::PRIORITY_HIDDEN;
|
|
}
|
|
else if(pimpl->hasFocus())
|
|
{
|
|
new_priority = LLViewerMediaImpl::PRIORITY_HIGH;
|
|
impl_count_interest_normal++; // count this against the count of "normal" instances for priority purposes
|
|
}
|
|
else if(pimpl->getUsedInUI())
|
|
{
|
|
new_priority = LLViewerMediaImpl::PRIORITY_NORMAL;
|
|
impl_count_interest_normal++;
|
|
}
|
|
else if(pimpl->isParcelMedia())
|
|
{
|
|
new_priority = LLViewerMediaImpl::PRIORITY_NORMAL;
|
|
impl_count_interest_normal++;
|
|
}
|
|
else
|
|
{
|
|
// Look at interest and CPU usage for instances that aren't in any of the above states.
|
|
|
|
// Heuristic -- if the media texture's approximate screen area is less than 1/4 of the native area of the texture,
|
|
// turn it down to low instead of normal. This may downsample for plugins that support it.
|
|
bool media_is_small = false;
|
|
F64 approximate_interest = pimpl->getApproximateTextureInterest();
|
|
if(approximate_interest == 0.0f)
|
|
{
|
|
// this media has no current size, which probably means it's not loaded.
|
|
media_is_small = true;
|
|
}
|
|
else if(pimpl->getInterest() < (approximate_interest / 4))
|
|
{
|
|
media_is_small = true;
|
|
}
|
|
|
|
if(pimpl->getInterest() == 0.0f)
|
|
{
|
|
// This media is completely invisible, due to being outside the view frustrum or out of range.
|
|
new_priority = LLViewerMediaImpl::PRIORITY_HIDDEN;
|
|
}
|
|
else if(check_cpu_usage && (total_cpu > max_cpu))
|
|
{
|
|
// Higher priority plugins have already used up the CPU budget. Set remaining ones to slideshow priority.
|
|
new_priority = LLViewerMediaImpl::PRIORITY_SLIDESHOW;
|
|
}
|
|
else if((impl_count_interest_normal < (int)max_normal) && !media_is_small)
|
|
{
|
|
// Up to max_normal inworld get normal priority
|
|
new_priority = LLViewerMediaImpl::PRIORITY_NORMAL;
|
|
impl_count_interest_normal++;
|
|
}
|
|
else if (impl_count_interest_low + impl_count_interest_normal < (int)max_low + (int)max_normal)
|
|
{
|
|
// The next max_low inworld get turned down
|
|
new_priority = LLViewerMediaImpl::PRIORITY_LOW;
|
|
impl_count_interest_low++;
|
|
|
|
// Set the low priority size for downsampling to approximately the size the texture is displayed at.
|
|
{
|
|
F32 approximate_interest_dimension = (F32) sqrt(pimpl->getInterest());
|
|
|
|
pimpl->setLowPrioritySizeLimit(ll_round(approximate_interest_dimension));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Any additional impls (up to max_instances) get very infrequent time
|
|
new_priority = LLViewerMediaImpl::PRIORITY_SLIDESHOW;
|
|
}
|
|
}
|
|
|
|
if(!pimpl->getUsedInUI() && (new_priority != LLViewerMediaImpl::PRIORITY_UNLOADED))
|
|
{
|
|
// This is a loadable inworld impl -- the last one in the list in this class defines the lowest loadable interest.
|
|
lowest_interest_loadable = pimpl;
|
|
|
|
impl_count_total++;
|
|
}
|
|
|
|
// Overrides if the window is minimized or we lost focus (taking care
|
|
// not to accidentally "raise" the priority either)
|
|
if (!gViewerWindow->getActive() /* viewer window minimized? */
|
|
&& new_priority > LLViewerMediaImpl::PRIORITY_HIDDEN)
|
|
{
|
|
new_priority = LLViewerMediaImpl::PRIORITY_HIDDEN;
|
|
}
|
|
else if (!gFocusMgr.getAppHasFocus() /* viewer window lost focus? */
|
|
&& new_priority > LLViewerMediaImpl::PRIORITY_LOW)
|
|
{
|
|
new_priority = LLViewerMediaImpl::PRIORITY_LOW;
|
|
}
|
|
|
|
if(!inworld_media_enabled)
|
|
{
|
|
// If inworld media is locked out, force all inworld media to stay unloaded.
|
|
if(!pimpl->getUsedInUI())
|
|
{
|
|
new_priority = LLViewerMediaImpl::PRIORITY_UNLOADED;
|
|
}
|
|
}
|
|
// update the audio stream here as well
|
|
if( !inworld_audio_enabled)
|
|
{
|
|
if(LLViewerMedia::isParcelAudioPlaying() && gAudiop && LLViewerMedia::hasParcelAudio())
|
|
{
|
|
gAudiop->stopInternetStream();
|
|
}
|
|
}
|
|
pimpl->setPriority(new_priority);
|
|
|
|
if(pimpl->getUsedInUI())
|
|
{
|
|
// Any impls used in the UI should not be in the proximity list.
|
|
pimpl->mProximity = -1;
|
|
}
|
|
else
|
|
{
|
|
proximity_order.push_back(pimpl);
|
|
}
|
|
|
|
total_cpu += pimpl->getCPUUsage();
|
|
|
|
if (!pimpl->getUsedInUI() && pimpl->hasMedia())
|
|
{
|
|
sAnyMediaShowing = true;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
// Re-calculate this every time.
|
|
sLowestLoadableImplInterest = 0.0f;
|
|
|
|
// Only do this calculation if we've hit the impl count limit -- up until that point we always need to load media data.
|
|
if(lowest_interest_loadable && (impl_count_total >= (int)max_instances))
|
|
{
|
|
// Get the interest value of this impl's object for use by isInterestingEnough
|
|
LLVOVolume *object = lowest_interest_loadable->getSomeObject();
|
|
if(object)
|
|
{
|
|
// NOTE: Don't use getMediaInterest() here. We want the pixel area, not the total media interest,
|
|
// so that we match up with the calculation done in LLMediaDataClient.
|
|
sLowestLoadableImplInterest = object->getPixelArea();
|
|
}
|
|
}
|
|
|
|
static LLCachedControl<bool> mediaPerformanceManager(gSavedSettings, "MediaPerformanceManagerDebug");
|
|
if(mediaPerformanceManager)
|
|
{
|
|
// Give impls the same ordering as the priority list
|
|
// they're already in the right order for this.
|
|
}
|
|
else
|
|
{
|
|
LLFastTimer t(FTM_MEDIA_SORT2);
|
|
// Use a distance-based sort for proximity values.
|
|
std::stable_sort(proximity_order.begin(), proximity_order.end(), proximity_comparitor);
|
|
}
|
|
|
|
// Transfer the proximity order to the proximity fields in the objects.
|
|
for(int i = 0; i < (int)proximity_order.size(); i++)
|
|
{
|
|
proximity_order[i]->mProximity = i;
|
|
}
|
|
|
|
LL_DEBUGS("PluginPriority") << "Total reported CPU usage is " << total_cpu << LL_ENDL;
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
bool LLViewerMedia::isAnyMediaShowing()
|
|
{
|
|
return sAnyMediaShowing;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::setAllMediaEnabled(bool val)
|
|
{
|
|
// Set "tentative" autoplay first. We need to do this here or else
|
|
// re-enabling won't start up the media below.
|
|
gSavedSettings.setBOOL("MediaTentativeAutoPlay", val);
|
|
|
|
// Then
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
|
|
for(; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
if (!pimpl->getUsedInUI())
|
|
{
|
|
pimpl->setDisabled(!val);
|
|
}
|
|
}
|
|
|
|
// Also do Parcel Media and Parcel Audio
|
|
if (val)
|
|
{
|
|
if (!LLViewerMedia::isParcelMediaPlaying() && LLViewerMedia::hasParcelMedia())
|
|
{
|
|
LLViewerParcelMedia::play(LLViewerParcelMgr::getInstance()->getAgentParcel());
|
|
}
|
|
|
|
if (gSavedSettings.getBOOL("AudioStreamingMusic") &&
|
|
!LLViewerMedia::isParcelAudioPlaying() &&
|
|
gAudiop &&
|
|
LLViewerMedia::hasParcelAudio())
|
|
{
|
|
if (LLAudioEngine::AUDIO_PAUSED == gAudiop->isInternetStreamPlaying())
|
|
{
|
|
// 'false' means unpause
|
|
gAudiop->pauseInternetStream(false);
|
|
}
|
|
else
|
|
{
|
|
LLViewerParcelMedia::playStreamingMusic(LLViewerParcelMgr::getInstance()->getAgentParcel());
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
// This actually unloads the impl, as opposed to "stop"ping the media
|
|
LLViewerParcelMedia::stop();
|
|
if (gAudiop)
|
|
{
|
|
gAudiop->stopInternetStream();
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
bool LLViewerMedia::isParcelMediaPlaying()
|
|
{
|
|
return (LLViewerMedia::hasParcelMedia() && LLViewerParcelMedia::getParcelMedia() && LLViewerParcelMedia::getParcelMedia()->hasMedia());
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
bool LLViewerMedia::isParcelAudioPlaying()
|
|
{
|
|
return (LLViewerMedia::hasParcelAudio() && gAudiop && LLAudioEngine::AUDIO_PLAYING == gAudiop->isInternetStreamPlaying());
|
|
}
|
|
|
|
void LLViewerMedia::onAuthSubmit(const LLSD& notification, const LLSD& response)
|
|
{
|
|
LLViewerMediaImpl *impl = LLViewerMedia::getMediaImplFromTextureID(notification["payload"]["media_id"]);
|
|
if(impl)
|
|
{
|
|
LLPluginClassMedia* media = impl->getMediaPlugin();
|
|
if(media)
|
|
{
|
|
if (response["ok"])
|
|
{
|
|
media->sendAuthResponse(true, response["username"], response["password"]);
|
|
}
|
|
else
|
|
{
|
|
media->sendAuthResponse(false, "", "");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::clearAllCookies()
|
|
{
|
|
// Clear all cookies for all plugins
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
for (; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
LLPluginClassMedia* plugin = pimpl->getMediaPlugin();
|
|
if(plugin)
|
|
{
|
|
plugin->clear_cookies();
|
|
}
|
|
}
|
|
|
|
// Clear all cookies from the cookie store
|
|
getCookieStore()->setAllCookies("");
|
|
|
|
// FIXME: this may not be sufficient, since the on-disk cookie file won't get written until some browser instance exits cleanly.
|
|
// It also won't clear cookies for other accounts, or for any account if we're not logged in, and won't do anything at all if there are no webkit plugins loaded.
|
|
// Until such time as we can centralize cookie storage, the following hack should cover these cases:
|
|
|
|
// HACK: Look for cookie files in all possible places and delete them.
|
|
// NOTE: this assumes knowledge of what happens inside the webkit plugin (it's what adds 'browser_profile' to the path and names the cookie file)
|
|
|
|
// Places that cookie files can be:
|
|
// <getOSUserAppDir>/browser_profile/cookies
|
|
// <getOSUserAppDir>/first_last/browser_profile/cookies (note that there may be any number of these!)
|
|
// <getOSUserAppDir>/first_last/plugin_cookies.txt (note that there may be any number of these!)
|
|
|
|
std::string base_dir = gDirUtilp->getOSUserAppDir() + gDirUtilp->getDirDelimiter();
|
|
std::string target;
|
|
std::string filename;
|
|
|
|
LL_DEBUGS() << "base dir = " << base_dir << LL_ENDL;
|
|
|
|
// The non-logged-in version is easy
|
|
target = base_dir;
|
|
target += "browser_profile";
|
|
target += gDirUtilp->getDirDelimiter();
|
|
target += "cookies";
|
|
LL_DEBUGS() << "target = " << target << LL_ENDL;
|
|
if(LLFile::isfile(target))
|
|
{
|
|
LLFile::remove(target);
|
|
}
|
|
|
|
// the hard part: iterate over all user directories and delete the cookie file from each one
|
|
LLDirIterator dir_iter(base_dir, "*_*");
|
|
while (dir_iter.next(filename))
|
|
{
|
|
target = gDirUtilp->add(base_dir, filename);
|
|
gDirUtilp->append(target, "browser_profile");
|
|
gDirUtilp->append(target, "cookies");
|
|
LL_DEBUGS() << "target = " << target << LL_ENDL;
|
|
if(LLFile::isfile(target))
|
|
{
|
|
LLFile::remove(target);
|
|
}
|
|
|
|
// Other accounts may have new-style cookie files too -- delete them as well
|
|
target = gDirUtilp->add(base_dir, filename);
|
|
gDirUtilp->append(target, PLUGIN_COOKIE_FILE_NAME);
|
|
LL_DEBUGS() << "target = " << target << LL_ENDL;
|
|
if(LLFile::isfile(target))
|
|
{
|
|
LLFile::remove(target);
|
|
}
|
|
}
|
|
|
|
// If we have an OpenID cookie, re-add it to the cookie store.
|
|
setOpenIDCookie();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::clearAllCaches()
|
|
{
|
|
// Clear all plugins' caches
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
for (; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
pimpl->clearCache();
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::setCookiesEnabled(bool enabled)
|
|
{
|
|
// Set the "cookies enabled" flag for all loaded plugins
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
for (; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
LLPluginClassMedia* plugin = pimpl->getMediaPlugin();
|
|
if(plugin)
|
|
{
|
|
plugin->enable_cookies(enabled);
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::setProxyConfig(bool enable, const std::string &host, int port)
|
|
{
|
|
// Set the proxy config for all loaded plugins
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
for (; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
LLPluginClassMedia* plugin = pimpl->getMediaPlugin();
|
|
if(plugin)
|
|
{
|
|
plugin->proxy_setup(enable, host, port);
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
LLPluginCookieStore *LLViewerMedia::getCookieStore()
|
|
{
|
|
if(sCookieStore == NULL)
|
|
{
|
|
sCookieStore = new LLPluginCookieStore;
|
|
}
|
|
|
|
return sCookieStore;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::loadCookieFile()
|
|
{
|
|
// build filename for each user
|
|
std::string resolved_filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, PLUGIN_COOKIE_FILE_NAME);
|
|
|
|
if (resolved_filename.empty())
|
|
{
|
|
LL_INFOS() << "can't get path to plugin cookie file - probably not logged in yet." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
// open the file for reading
|
|
llifstream file(resolved_filename);
|
|
if (!file.is_open())
|
|
{
|
|
LL_WARNS() << "can't load plugin cookies from file \"" << PLUGIN_COOKIE_FILE_NAME << "\"" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
getCookieStore()->readAllCookies(file, true);
|
|
|
|
file.close();
|
|
|
|
// send the clear_cookies message to all loaded plugins
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
for (; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
LLPluginClassMedia* plugin = pimpl->getMediaPlugin();
|
|
if(plugin)
|
|
{
|
|
plugin->clear_cookies();
|
|
}
|
|
}
|
|
|
|
// If we have an OpenID cookie, re-add it to the cookie store.
|
|
setOpenIDCookie();
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::saveCookieFile()
|
|
{
|
|
// build filename for each user
|
|
std::string resolved_filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, PLUGIN_COOKIE_FILE_NAME);
|
|
|
|
if (resolved_filename.empty())
|
|
{
|
|
LL_INFOS() << "can't get path to plugin cookie file - probably not logged in yet." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
// open a file for writing
|
|
llofstream file (resolved_filename);
|
|
if (!file.is_open())
|
|
{
|
|
LL_WARNS() << "can't open plugin cookie file \"" << PLUGIN_COOKIE_FILE_NAME << "\" for writing" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
getCookieStore()->writePersistentCookies(file);
|
|
|
|
file.close();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::addCookie(const std::string &name, const std::string &value, const std::string &domain, const LLDate &expires, const std::string &path, bool secure)
|
|
{
|
|
std::stringstream cookie;
|
|
|
|
cookie << name << "=" << LLPluginCookieStore::quoteString(value);
|
|
|
|
if(expires.notNull())
|
|
{
|
|
cookie << "; expires=" << expires.asRFC1123();
|
|
}
|
|
|
|
cookie << "; domain=" << domain;
|
|
|
|
cookie << "; path=" << path;
|
|
|
|
if(secure)
|
|
{
|
|
cookie << "; secure";
|
|
}
|
|
|
|
getCookieStore()->setCookies(cookie.str());
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::addSessionCookie(const std::string &name, const std::string &value, const std::string &domain, const std::string &path, bool secure)
|
|
{
|
|
// A session cookie just has a NULL date.
|
|
addCookie(name, value, domain, LLDate(), path, secure);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::removeCookie(const std::string &name, const std::string &domain, const std::string &path )
|
|
{
|
|
// To remove a cookie, add one with the same name, domain, and path that expires in the past.
|
|
|
|
addCookie(name, "", domain, LLDate(LLDate::now().secondsSinceEpoch() - 1.0), path);
|
|
}
|
|
|
|
|
|
AIHTTPHeaders LLViewerMedia::getHeaders()
|
|
{
|
|
AIHTTPHeaders headers;
|
|
headers.addHeader("Accept", "*/*");
|
|
// *TODO: Should this be 'application/llsd+xml' ?
|
|
// *TODO: Should this even be set at all? This header is only not overridden in 'GET' methods.
|
|
headers.addHeader("Content-Type", "application/xml");
|
|
headers.addHeader("Cookie", sOpenIDCookie);
|
|
headers.addHeader("User-Agent", getCurrentUserAgent());
|
|
|
|
return headers;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::setOpenIDCookie()
|
|
{
|
|
if(!sOpenIDCookie.empty())
|
|
{
|
|
// The LLURL can give me the 'authority', which is of the form: [username[:password]@]hostname[:port]
|
|
// We want just the hostname for the cookie code, but LLURL doesn't seem to have a way to extract that.
|
|
// We therefore do it here.
|
|
std::string authority = sOpenIDURL.mAuthority;
|
|
std::string::size_type host_start = authority.find('@');
|
|
if(host_start == std::string::npos)
|
|
{
|
|
// no username/password
|
|
host_start = 0;
|
|
}
|
|
else
|
|
{
|
|
// Hostname starts after the @.
|
|
// (If the hostname part is empty, this may put host_start at the end of the string. In that case, it will end up passing through an empty hostname, which is correct.)
|
|
++host_start;
|
|
}
|
|
std::string::size_type host_end = authority.rfind(':');
|
|
if((host_end == std::string::npos) || (host_end < host_start))
|
|
{
|
|
// no port
|
|
host_end = authority.size();
|
|
}
|
|
|
|
getCookieStore()->setCookiesFromHost(sOpenIDCookie, authority.substr(host_start, host_end - host_start));
|
|
|
|
if (gSavedSettings.getString("WebProfileURL").empty()) return;
|
|
// Do a web profile get so we can store the cookie
|
|
AIHTTPHeaders headers;
|
|
headers.addHeader("Accept", "*/*");
|
|
headers.addHeader("Cookie", sOpenIDCookie);
|
|
headers.addHeader("User-Agent", getCurrentUserAgent());
|
|
|
|
std::string profile_url = getProfileURL("");
|
|
LLURL raw_profile_url( profile_url.c_str() );
|
|
|
|
LL_DEBUGS("MediaAuth") << "Requesting " << profile_url << LL_ENDL;
|
|
LL_DEBUGS("MediaAuth") << "sOpenIDCookie = [" << sOpenIDCookie << "]" << LL_ENDL;
|
|
LLHTTPClient::get(profile_url,
|
|
new LLViewerMediaWebProfileResponder(raw_profile_url.getAuthority()),
|
|
headers);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::openIDSetup(const std::string &openid_url, const std::string &openid_token)
|
|
{
|
|
LL_DEBUGS("MediaAuth") << "url = \"" << openid_url << "\", token = \"" << openid_token << "\"" << LL_ENDL;
|
|
|
|
// post the token to the url
|
|
// the responder will need to extract the cookie(s).
|
|
|
|
// Save the OpenID URL for later -- we may need the host when adding the cookie.
|
|
sOpenIDURL.init(openid_url.c_str());
|
|
|
|
// We shouldn't ever do this twice, but just in case this code gets repurposed later, clear existing cookies.
|
|
sOpenIDCookie.clear();
|
|
|
|
AIHTTPHeaders headers;
|
|
// Keep LLHTTPClient from adding an "Accept: application/llsd+xml" header
|
|
headers.addHeader("Accept", "*/*");
|
|
// and use the expected content-type for a post, instead of the LLHTTPClient::postRaw() default of "application/octet-stream"
|
|
headers.addHeader("Content-Type", "application/x-www-form-urlencoded");
|
|
|
|
// postRaw() takes ownership of the buffer and releases it later, so we need to allocate a new buffer here.
|
|
size_t size = openid_token.size();
|
|
U8* data = new U8[size];
|
|
memcpy(data, openid_token.data(), size);
|
|
|
|
LLHTTPClient::postRaw(
|
|
openid_url,
|
|
data,
|
|
size,
|
|
new LLViewerMediaOpenIDResponder(),
|
|
headers);
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::openIDCookieResponse(const std::string &cookie)
|
|
{
|
|
LL_DEBUGS("MediaAuth") << "Cookie received: \"" << cookie << "\"" << LL_ENDL;
|
|
|
|
sOpenIDCookie += cookie;
|
|
|
|
setOpenIDCookie();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::proxyWindowOpened(const std::string &target, const std::string &uuid)
|
|
{
|
|
if(uuid.empty())
|
|
return;
|
|
|
|
for (impl_list::iterator iter = sViewerMediaImplList.begin(); iter != sViewerMediaImplList.end(); iter++)
|
|
{
|
|
LLPluginClassMedia* plugin = (*iter)->getMediaPlugin();
|
|
if(plugin && plugin->pluginSupportsMediaBrowser())
|
|
{
|
|
plugin->proxyWindowOpened(target, uuid);
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::proxyWindowClosed(const std::string &uuid)
|
|
{
|
|
if(uuid.empty())
|
|
return;
|
|
|
|
for (impl_list::iterator iter = sViewerMediaImplList.begin(); iter != sViewerMediaImplList.end(); iter++)
|
|
{
|
|
LLPluginClassMedia* plugin = (*iter)->getMediaPlugin();
|
|
if(plugin && plugin->pluginSupportsMediaBrowser())
|
|
{
|
|
plugin->proxyWindowClosed(uuid);
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::createSpareBrowserMediaSource()
|
|
{
|
|
static bool failedLoading = false;
|
|
if (failedLoading) return;
|
|
|
|
// If we don't have a spare browser media source, create one.
|
|
// However, if PluginAttachDebuggerToPlugins is set then don't spawn a spare
|
|
// SLPlugin process in order to not be confused by an unrelated gdb terminal
|
|
// popping up at the moment we start a media plugin.
|
|
if (!sSpareBrowserMediaSource && !gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins"))
|
|
{
|
|
// The null owner will keep the browser plugin from fully initializing
|
|
// (specifically, it keeps LLPluginClassMedia from negotiating a size change,
|
|
// which keeps MediaPluginWebkit::initBrowserWindow from doing anything until we have some necessary data, like the background color)
|
|
sSpareBrowserMediaSource = LLViewerMediaImpl::newSourceFromMediaType("text/html", NULL, 0, 0);
|
|
if (!sSpareBrowserMediaSource) failedLoading = true;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
LLPluginClassMedia* LLViewerMedia::getSpareBrowserMediaSource()
|
|
{
|
|
LLPluginClassMedia* result = sSpareBrowserMediaSource;
|
|
sSpareBrowserMediaSource = NULL;
|
|
return result;
|
|
};
|
|
|
|
bool LLViewerMedia::hasInWorldMedia()
|
|
{
|
|
impl_list::iterator iter = sViewerMediaImplList.begin();
|
|
impl_list::iterator end = sViewerMediaImplList.end();
|
|
// This should be quick, because there should be very few non-in-world-media impls
|
|
for (; iter != end; iter++)
|
|
{
|
|
LLViewerMediaImpl* pimpl = *iter;
|
|
if (!pimpl->getUsedInUI() && !pimpl->isParcelMedia())
|
|
{
|
|
// Found an in-world media impl
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
bool LLViewerMedia::hasParcelMedia()
|
|
{
|
|
return !LLViewerParcelMedia::getURL().empty();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
bool LLViewerMedia::hasParcelAudio()
|
|
{
|
|
return !LLViewerMedia::getParcelAudioURL().empty();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
std::string LLViewerMedia::getParcelAudioURL()
|
|
{
|
|
return LLViewerParcelMgr::getInstance()->getAgentParcel()->getMusicURL();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::initClass()
|
|
{
|
|
gIdleCallbacks.addFunction(LLViewerMedia::updateMedia, NULL);
|
|
sTeleportFinishConnection = LLViewerParcelMgr::getInstance()->
|
|
setTeleportFinishedCallback(boost::bind(&LLViewerMedia::onTeleportFinished));
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::cleanupClass()
|
|
{
|
|
gIdleCallbacks.deleteFunction(LLViewerMedia::updateMedia, NULL);
|
|
sTeleportFinishConnection.disconnect();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::onTeleportFinished()
|
|
{
|
|
// On teleport, clear this setting (i.e. set it to true)
|
|
gSavedSettings.setBOOL("MediaTentativeAutoPlay", true);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// static
|
|
void LLViewerMedia::setOnlyAudibleMediaTextureID(const LLUUID& texture_id)
|
|
{
|
|
sOnlyAudibleTextureID = texture_id;
|
|
sForceUpdate = true;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
// LLViewerMediaImpl
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
LLViewerMediaImpl::LLViewerMediaImpl( const LLUUID& texture_id,
|
|
S32 media_width,
|
|
S32 media_height,
|
|
U8 media_auto_scale,
|
|
U8 media_loop)
|
|
:
|
|
mMovieImageHasMips(false),
|
|
mMediaWidth(media_width),
|
|
mMediaHeight(media_height),
|
|
mMediaAutoScale(media_auto_scale),
|
|
mMediaLoop(media_loop),
|
|
mNeedsNewTexture(true),
|
|
mTextureUsedWidth(0),
|
|
mTextureUsedHeight(0),
|
|
mSuspendUpdates(false),
|
|
mVisible(true),
|
|
mLastSetCursor( UI_CURSOR_ARROW ),
|
|
mMediaNavState( MEDIANAVSTATE_NONE ),
|
|
mInterest(0.0f),
|
|
mUsedInUI(false),
|
|
mHasFocus(false),
|
|
mPriority(PRIORITY_UNLOADED),
|
|
mNavigateRediscoverType(false),
|
|
mNavigateServerRequest(false),
|
|
mMediaSourceFailed(false),
|
|
mRequestedVolume(1.0f),
|
|
mIsMuted(false),
|
|
mNeedsMuteCheck(false),
|
|
mPreviousMediaState(MEDIA_NONE),
|
|
mPreviousMediaTime(0.0f),
|
|
mIsDisabled(false),
|
|
mIsParcelMedia(false),
|
|
mProximity(-1),
|
|
mProximityDistance(0.0f),
|
|
mMimeTypeProbe(NULL),
|
|
mMediaAutoPlay(false),
|
|
mInNearbyMediaList(false),
|
|
mClearCache(false),
|
|
mBackgroundColor(LLColor4::white),
|
|
mNavigateSuspended(false),
|
|
mNavigateSuspendedDeferred(false),
|
|
mIsUpdated(false),
|
|
mTrustedBrowser(false),
|
|
mZoomFactor(1.0)
|
|
{
|
|
|
|
// Set up the mute list observer if it hasn't been set up already.
|
|
if(!sViewerMediaMuteListObserverInitialized)
|
|
{
|
|
LLMuteList::getInstance()->addObserver(&sViewerMediaMuteListObserver);
|
|
sViewerMediaMuteListObserverInitialized = true;
|
|
}
|
|
|
|
add_media_impl(this);
|
|
|
|
setTextureID(texture_id);
|
|
|
|
// connect this media_impl to the media texture, creating it if it doesn't exist.0
|
|
// This is necessary because we need to be able to use getMaxVirtualSize() even if the media plugin is not loaded.
|
|
LLViewerMediaTexture* media_tex = LLViewerTextureManager::getMediaTexture(mTextureId);
|
|
if(media_tex)
|
|
{
|
|
media_tex->setMediaImpl();
|
|
}
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
LLViewerMediaImpl::~LLViewerMediaImpl()
|
|
{
|
|
destroyMediaSource();
|
|
|
|
LLViewerMediaTexture::removeMediaImplFromTexture(mTextureId) ;
|
|
|
|
setTextureID();
|
|
remove_media_impl(this);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::emitEvent(LLPluginClassMedia* plugin, LLViewerMediaObserver::EMediaEvent event)
|
|
{
|
|
// Broadcast to observers using the superclass version
|
|
LLViewerMediaEventEmitter::emitEvent(plugin, event);
|
|
|
|
// If this media is on one or more LLVOVolume objects, tell them about the event as well.
|
|
std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
|
|
while(iter != mObjectList.end())
|
|
{
|
|
LLVOVolume *self = *iter;
|
|
++iter;
|
|
self->mediaEvent(this, plugin, event);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::initializeMedia(const std::string& mime_type)
|
|
{
|
|
bool mimeTypeChanged = (mMimeType != mime_type);
|
|
bool pluginChanged = (LLMIMETypes::implType(mCurrentMimeType) != LLMIMETypes::implType(mime_type));
|
|
|
|
if(!mPluginBase || pluginChanged)
|
|
{
|
|
// We don't have a plugin at all, or the new mime type is handled by a different plugin than the old mime type.
|
|
(void)initializePlugin(mime_type);
|
|
}
|
|
else if(mimeTypeChanged)
|
|
{
|
|
// The same plugin should be able to handle the new media -- just update the stored mime type.
|
|
mMimeType = mime_type;
|
|
}
|
|
|
|
return (mPluginBase != NULL);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::createMediaSource()
|
|
{
|
|
if(mPriority == PRIORITY_UNLOADED)
|
|
{
|
|
// This media shouldn't be created yet.
|
|
return;
|
|
}
|
|
|
|
if(! mMediaURL.empty())
|
|
{
|
|
navigateInternal();
|
|
}
|
|
else if(! mMimeType.empty())
|
|
{
|
|
if (!initializeMedia(mMimeType))
|
|
{
|
|
LL_WARNS("Media") << "Failed to initialize media for mime type " << mMimeType << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::destroyMediaSource()
|
|
{
|
|
mNeedsNewTexture = true;
|
|
|
|
// Tell the viewer media texture it's no longer active
|
|
LLViewerMediaTexture* oldImage = LLViewerTextureManager::findMediaTexture( mTextureId );
|
|
if (oldImage)
|
|
{
|
|
oldImage->setPlaying(FALSE) ;
|
|
}
|
|
|
|
cancelMimeTypeProbe();
|
|
|
|
if(mPluginBase)
|
|
{
|
|
mPluginBase->setDeleteOK(true) ;
|
|
destroyPlugin();
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::setMediaType(const std::string& media_type)
|
|
{
|
|
mMimeType = media_type;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
/*static*/
|
|
LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_type, LLPluginClassMediaOwner *owner /* may be NULL */, S32 default_width, S32 default_height, const std::string target)
|
|
{
|
|
std::string plugin_basename = LLMIMETypes::implType(media_type);
|
|
LLPluginClassMedia* media_source = NULL;
|
|
|
|
// HACK: we always try to keep a spare running webkit plugin around to improve launch times.
|
|
// If a spare was already created before PluginAttachDebuggerToPlugins was set, don't use it.
|
|
if ((plugin_basename == "media_plugin_cef") &&
|
|
!gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins"))
|
|
{
|
|
media_source = LLViewerMedia::getSpareBrowserMediaSource();
|
|
if(media_source)
|
|
{
|
|
media_source->setOwner(owner);
|
|
media_source->setTarget(target);
|
|
media_source->setSize(default_width, default_height);
|
|
|
|
return media_source;
|
|
}
|
|
}
|
|
if(plugin_basename.empty())
|
|
{
|
|
LL_WARNS_ONCE("Media") << "Couldn't find plugin for media type " << media_type << LL_ENDL;
|
|
}
|
|
else
|
|
{
|
|
std::string launcher_name = gDirUtilp->getLLPluginLauncher();
|
|
std::string plugin_name = gDirUtilp->getLLPluginFilename(plugin_basename);
|
|
|
|
std::string user_data_path_cache = gDirUtilp->getCacheDir(false);
|
|
user_data_path_cache += gDirUtilp->getDirDelimiter();
|
|
|
|
std::string user_data_path_cookies = gDirUtilp->getOSUserAppDir();
|
|
user_data_path_cookies += gDirUtilp->getDirDelimiter();
|
|
|
|
std::string user_data_path_logs = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "");
|
|
|
|
// Fix for EXT-5960 - make browser profile specific to user (cache, cookies etc.)
|
|
// If the linden username returned is blank, that can only mean we are
|
|
// at the login page displaying login Web page or Web browser test via Develop menu.
|
|
// In this case we just use whatever gDirUtilp->getOSUserAppDir() gives us (this
|
|
// is what we always used before this change)
|
|
std::string linden_user_dir = gDirUtilp->getLindenUserDir();
|
|
if ( ! linden_user_dir.empty() )
|
|
{
|
|
// gDirUtilp->getLindenUserDir() is whole path, not just Linden name
|
|
user_data_path_cookies = linden_user_dir;
|
|
user_data_path_cookies += gDirUtilp->getDirDelimiter();
|
|
};
|
|
|
|
// See if the plugin executable exists
|
|
llstat s;
|
|
if(LLFile::stat(launcher_name, &s))
|
|
{
|
|
LL_WARNS_ONCE("Media") << "Couldn't find launcher at " << launcher_name << LL_ENDL;
|
|
}
|
|
else if(LLFile::stat(plugin_name, &s))
|
|
{
|
|
LL_WARNS_ONCE("Media") << "Couldn't find plugin at " << plugin_name << LL_ENDL;
|
|
}
|
|
else
|
|
{
|
|
media_source = new LLPluginClassMedia(owner);
|
|
media_source->setSize(default_width, default_height);
|
|
media_source->setUserDataPath(user_data_path_cache, user_data_path_cookies, user_data_path_logs);
|
|
media_source->setLanguageCode(LLUI::getLanguage());
|
|
|
|
// collect 'cookies enabled' setting from prefs and send to embedded browser
|
|
bool cookies_enabled = gSavedSettings.getBOOL( "CookiesEnabled" );
|
|
media_source->enable_cookies( cookies_enabled );
|
|
|
|
// collect 'plugins enabled' setting from prefs and send to embedded browser
|
|
bool plugins_enabled = gSavedSettings.getBOOL( "BrowserPluginsEnabled" );
|
|
media_source->setPluginsEnabled( plugins_enabled );
|
|
|
|
// collect 'javascript enabled' setting from prefs and send to embedded browser
|
|
bool javascript_enabled = gSavedSettings.getBOOL( "BrowserJavascriptEnabled" );
|
|
media_source->setJavascriptEnabled( javascript_enabled );
|
|
|
|
bool media_plugin_debugging_enabled = gSavedSettings.getBOOL("MediaPluginDebugging");
|
|
media_source->enableMediaPluginDebugging( media_plugin_debugging_enabled );
|
|
|
|
// need to set agent string here before instance created
|
|
media_source->setBrowserUserAgent(LLViewerMedia::getCurrentUserAgent());
|
|
|
|
media_source->setTarget(target);
|
|
|
|
const std::string plugin_dir = gDirUtilp->getLLPluginDir();
|
|
if (media_source->init(launcher_name, plugin_dir, plugin_name, gSavedSettings.getBOOL("PluginAttachDebuggerToPlugins")))
|
|
{
|
|
return media_source;
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("Media") << "Failed to init plugin. Destroying." << LL_ENDL;
|
|
delete media_source;
|
|
}
|
|
}
|
|
}
|
|
|
|
LL_WARNS_ONCE("Plugin") << "plugin initialization failed for mime type: " << media_type << LL_ENDL;
|
|
/* There is a reason why ^^ is ONCE
|
|
LLSD args;
|
|
args["MIME_TYPE"] = media_type;
|
|
LLNotificationsUtil::add("NoPlugin", args);
|
|
*/
|
|
return NULL;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::initializePlugin(const std::string& media_type)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
// Save the previous media source's last set size before destroying it.
|
|
mMediaWidth = mMediaSource->getSetWidth();
|
|
mMediaHeight = mMediaSource->getSetHeight();
|
|
}
|
|
|
|
// Always delete the old media impl first.
|
|
destroyMediaSource();
|
|
|
|
// and unconditionally set the mime type
|
|
mMimeType = media_type;
|
|
|
|
if(mPriority == PRIORITY_UNLOADED)
|
|
{
|
|
// This impl should not be loaded at this time.
|
|
LL_DEBUGS("PluginPriority") << this << "Not loading (PRIORITY_UNLOADED)" << LL_ENDL;
|
|
|
|
return false;
|
|
}
|
|
|
|
// If we got here, we want to ignore previous init failures.
|
|
mMediaSourceFailed = false;
|
|
|
|
// Save the MIME type that really caused the plugin to load
|
|
mCurrentMimeType = mMimeType;
|
|
|
|
LLPluginClassMedia* media_source = newSourceFromMediaType(mMimeType, this, mMediaWidth, mMediaHeight, mTarget);
|
|
|
|
if (media_source)
|
|
{
|
|
media_source->setDisableTimeout(gSavedSettings.getBOOL("DebugPluginDisableTimeout"));
|
|
media_source->setLoop(mMediaLoop);
|
|
media_source->setAutoScale(mMediaAutoScale);
|
|
media_source->setBrowserUserAgent(LLViewerMedia::getCurrentUserAgent());
|
|
media_source->focus(mHasFocus);
|
|
media_source->setBackgroundColor(mBackgroundColor);
|
|
|
|
if(gSavedSettings.getBOOL("BrowserIgnoreSSLCertErrors"))
|
|
{
|
|
media_source->ignore_ssl_cert_errors(true);
|
|
}
|
|
|
|
// the correct way to deal with certs it to load ours from CA.pem and append them to the ones
|
|
// Qt/WebKit loads from your system location.
|
|
// Note: This needs the new CA.pem file with the Equifax Secure Certificate Authority
|
|
// cert at the bottom: (MIIDIDCCAomgAwIBAgIENd70zzANBg)
|
|
std::string ca_path = gDirUtilp->getExpandedFilename( LL_PATH_APP_SETTINGS, "CA.pem" );
|
|
media_source->addCertificateFilePath( ca_path );
|
|
|
|
media_source->proxy_setup(gSavedSettings.getBOOL("BrowserProxyEnabled"), gSavedSettings.getString("BrowserProxyAddress"), gSavedSettings.getS32("BrowserProxyPort"));
|
|
|
|
if(mClearCache)
|
|
{
|
|
mClearCache = false;
|
|
media_source->clear_cache();
|
|
}
|
|
|
|
// TODO: Only send cookies to plugins that need them
|
|
// Ideally, the plugin should tell us whether it handles cookies or not -- either via the init response or through a separate message.
|
|
// Due to the ordering of messages, it's possible we wouldn't get that information back in time to send cookies before sending a navigate message,
|
|
// which could cause odd race conditions.
|
|
std::string all_cookies = LLViewerMedia::getCookieStore()->getAllCookies();
|
|
LL_DEBUGS() << "setting cookies: " << all_cookies << LL_ENDL;
|
|
if(!all_cookies.empty())
|
|
{
|
|
media_source->set_cookies(all_cookies);
|
|
}
|
|
|
|
mPluginBase = media_source;
|
|
mPluginBase->setDeleteOK(false) ;
|
|
updateVolume();
|
|
|
|
return true;
|
|
}
|
|
|
|
// Make sure the timer doesn't try re-initing this plugin repeatedly until something else changes.
|
|
mMediaSourceFailed = true;
|
|
|
|
return false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::loadURI()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
// trim whitespace from front and back of URL - fixes EXT-5363
|
|
LLStringUtil::trim( mMediaURL );
|
|
|
|
// *HACK: we don't know if the URI coming in is properly escaped
|
|
// (the contract doesn't specify whether it is escaped or not.
|
|
// but LLQtWebKit expects it to be, so we do our best to encode
|
|
// special characters)
|
|
// The strings below were taken right from http://www.ietf.org/rfc/rfc1738.txt
|
|
// Note especially that '%' and '/' are there.
|
|
std::string uri = LLURI::escape(mMediaURL,
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
|
|
"0123456789"
|
|
"$-_.+"
|
|
"!*'(),"
|
|
"{}|\\^~[]`"
|
|
"<>#%"
|
|
";/?:@&=",
|
|
false);
|
|
{
|
|
// Do not log the query parts
|
|
LLURI u(uri);
|
|
std::string sanitized_uri = (u.query().empty() ? uri : u.scheme() + "://" + u.authority() + u.path());
|
|
LL_INFOS() << "Asking media source to load URI: " << sanitized_uri << LL_ENDL;
|
|
}
|
|
|
|
mMediaSource->loadURI( uri );
|
|
|
|
// A non-zero mPreviousMediaTime means that either this media was previously unloaded by the priority code while playing/paused,
|
|
// or a seek happened before the media loaded. In either case, seek to the saved time.
|
|
if(mPreviousMediaTime != 0.0f)
|
|
{
|
|
seek(mPreviousMediaTime);
|
|
}
|
|
|
|
if(mPreviousMediaState == MEDIA_PLAYING)
|
|
{
|
|
// This media was playing before this instance was unloaded.
|
|
start();
|
|
}
|
|
else if(mPreviousMediaState == MEDIA_PAUSED)
|
|
{
|
|
// This media was paused before this instance was unloaded.
|
|
pause();
|
|
}
|
|
else
|
|
{
|
|
// No relevant previous media play state -- if we're loading the URL, we want to start playing.
|
|
start();
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::setSize(int width, int height)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
mMediaWidth = width;
|
|
mMediaHeight = height;
|
|
if (mMediaSource)
|
|
{
|
|
mMediaSource->setSize(width, height);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::showNotification(LLNotificationPtr notify)
|
|
{
|
|
mNotification = notify;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::hideNotification()
|
|
{
|
|
mNotification.reset();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::play()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
|
|
// If the media source isn't there, try to initialize it and load an URL.
|
|
if(mMediaSource == NULL)
|
|
{
|
|
if(!initializeMedia(mMimeType))
|
|
{
|
|
// This may be the case where the plugin's priority is PRIORITY_UNLOADED
|
|
return;
|
|
}
|
|
|
|
// Only do this if the media source was just loaded.
|
|
loadURI();
|
|
}
|
|
|
|
// always start the media
|
|
start();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::stop()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
mMediaSource->stop();
|
|
// destroyMediaSource();
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::pause()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
mMediaSource->pause();
|
|
}
|
|
else
|
|
{
|
|
mPreviousMediaState = MEDIA_PAUSED;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::start()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
mMediaSource->start();
|
|
}
|
|
else
|
|
{
|
|
mPreviousMediaState = MEDIA_PLAYING;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::seek(F32 time)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
mMediaSource->seek(time);
|
|
}
|
|
else
|
|
{
|
|
// Save the seek time to be set when the media is loaded.
|
|
mPreviousMediaTime = time;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::skipBack(F32 step_scale)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
if(mMediaSource->pluginSupportsMediaTime())
|
|
{
|
|
F64 back_step = mMediaSource->getCurrentTime() - (mMediaSource->getDuration()*step_scale);
|
|
if(back_step < 0.0)
|
|
{
|
|
back_step = 0.0;
|
|
}
|
|
mMediaSource->seek(back_step);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::skipForward(F32 step_scale)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
if(mMediaSource->pluginSupportsMediaTime())
|
|
{
|
|
F64 forward_step = mMediaSource->getCurrentTime() + (mMediaSource->getDuration()*step_scale);
|
|
if(forward_step > mMediaSource->getDuration())
|
|
{
|
|
forward_step = mMediaSource->getDuration();
|
|
}
|
|
mMediaSource->seek(forward_step);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::setVolume(F32 volume)
|
|
{
|
|
mRequestedVolume = volume;
|
|
updateVolume();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::updateVolume()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
// always scale the volume by the global media volume
|
|
F32 volume = mRequestedVolume * LLViewerMedia::getVolume();
|
|
|
|
if (mProximityCamera > 0)
|
|
{
|
|
static LLCachedControl<F32> sMediaRollOffMax(gSavedSettings, "MediaRollOffMax", 30.f);
|
|
static LLCachedControl<F32> sMediaRollOffMin(gSavedSettings, "MediaRollOffMin", 5.f);
|
|
static LLCachedControl<F32> sMediaRollOffRate(gSavedSettings, "MediaRollOffRate", 0.125f);
|
|
if (mProximityCamera > sMediaRollOffMax)
|
|
{
|
|
volume = 0;
|
|
}
|
|
else if (mProximityCamera > sMediaRollOffMin)
|
|
{
|
|
// attenuated_volume = 1 / (roll_off_rate * (d - min))^2
|
|
// the +1 is there so that for distance 0 the volume stays the same
|
|
F64 adjusted_distance = mProximityCamera - sMediaRollOffMin;
|
|
F64 attenuation = 1.0 + (sMediaRollOffRate * adjusted_distance);
|
|
attenuation = 1.0 / (attenuation * attenuation);
|
|
// the attenuation multiplier should never be more than one since that would increase volume
|
|
volume = volume * llmin(1.0, attenuation);
|
|
}
|
|
}
|
|
|
|
if (sOnlyAudibleTextureID == LLUUID::null || sOnlyAudibleTextureID == mTextureId)
|
|
{
|
|
mMediaSource->setVolume(volume);
|
|
}
|
|
else
|
|
{
|
|
mMediaSource->setVolume(0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
F32 LLViewerMediaImpl::getVolume()
|
|
{
|
|
return mRequestedVolume;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::focus(bool focus)
|
|
{
|
|
mHasFocus = focus;
|
|
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
{
|
|
// call focus just for the hell of it, even though this apopears to be a nop
|
|
mMediaSource->focus(focus);
|
|
if (focus)
|
|
{
|
|
// spoof a mouse click to *actually* pass focus
|
|
// Don't do this anymore -- it actually clicks through now.
|
|
// mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOWN, 1, 1, 0);
|
|
// mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, 1, 1, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::hasFocus() const
|
|
{
|
|
// FIXME: This might be able to be a bit smarter by hooking into LLViewerMediaFocus, etc.
|
|
return mHasFocus;
|
|
}
|
|
|
|
std::string LLViewerMediaImpl::getCurrentMediaURL()
|
|
{
|
|
if(!mCurrentMediaURL.empty())
|
|
{
|
|
return mCurrentMediaURL;
|
|
}
|
|
|
|
return mMediaURL;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::clearCache()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
mMediaSource->clear_cache();
|
|
}
|
|
else
|
|
{
|
|
mClearCache = true;
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::setPageZoomFactor( double factor )
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource && factor != mZoomFactor)
|
|
{
|
|
mZoomFactor = factor;
|
|
mMediaSource->set_page_zoom_factor( factor );
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::mouseDown(S32 x, S32 y, MASK mask, S32 button)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
scaleMouse(&x, &y);
|
|
mLastMouseX = x;
|
|
mLastMouseY = y;
|
|
// LL_INFOS() << "mouse down (" << x << ", " << y << ")" << LL_ENDL;
|
|
if (mMediaSource)
|
|
{
|
|
mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOWN, button, x, y, mask);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::mouseUp(S32 x, S32 y, MASK mask, S32 button)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
scaleMouse(&x, &y);
|
|
mLastMouseX = x;
|
|
mLastMouseY = y;
|
|
// LL_INFOS() << "mouse up (" << x << ", " << y << ")" << LL_ENDL;
|
|
if (mMediaSource)
|
|
{
|
|
mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, button, x, y, mask);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::mouseMove(S32 x, S32 y, MASK mask)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
scaleMouse(&x, &y);
|
|
mLastMouseX = x;
|
|
mLastMouseY = y;
|
|
// LL_INFOS() << "mouse move (" << x << ", " << y << ")" << LL_ENDL;
|
|
if (mMediaSource)
|
|
{
|
|
mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_MOVE, 0, x, y, mask);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//static
|
|
void LLViewerMediaImpl::scaleTextureCoords(const LLVector2& texture_coords, S32 *x, S32 *y)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
F32 texture_x = texture_coords.mV[VX];
|
|
F32 texture_y = texture_coords.mV[VY];
|
|
|
|
// Deal with repeating textures by wrapping the coordinates into the range [0, 1.0)
|
|
texture_x = fmodf(texture_x, 1.0f);
|
|
if(texture_x < 0.0f)
|
|
texture_x = 1.0 + texture_x;
|
|
|
|
texture_y = fmodf(texture_y, 1.0f);
|
|
if(texture_y < 0.0f)
|
|
texture_y = 1.0 + texture_y;
|
|
|
|
// scale x and y to texel units.
|
|
*x = ll_round(texture_x * mMediaSource->getTextureWidth());
|
|
*y = ll_round((1.0f - texture_y) * mMediaSource->getTextureHeight());
|
|
|
|
// Adjust for the difference between the actual texture height and the amount of the texture in use.
|
|
*y -= (mMediaSource->getTextureHeight() - mMediaSource->getHeight());
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::mouseDown(const LLVector2& texture_coords, MASK mask, S32 button)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
S32 x, y;
|
|
scaleTextureCoords(texture_coords, &x, &y);
|
|
|
|
mouseDown(x, y, mask, button);
|
|
}
|
|
}
|
|
|
|
void LLViewerMediaImpl::mouseUp(const LLVector2& texture_coords, MASK mask, S32 button)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
S32 x, y;
|
|
scaleTextureCoords(texture_coords, &x, &y);
|
|
|
|
mouseUp(x, y, mask, button);
|
|
}
|
|
}
|
|
|
|
void LLViewerMediaImpl::mouseMove(const LLVector2& texture_coords, MASK mask)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
S32 x, y;
|
|
scaleTextureCoords(texture_coords, &x, &y);
|
|
|
|
mouseMove(x, y, mask);
|
|
}
|
|
}
|
|
|
|
void LLViewerMediaImpl::mouseDoubleClick(const LLVector2& texture_coords, MASK mask)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
{
|
|
S32 x, y;
|
|
scaleTextureCoords(texture_coords, &x, &y);
|
|
|
|
mouseDoubleClick(x, y, mask);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::mouseDoubleClick(S32 x, S32 y, MASK mask, S32 button)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
scaleMouse(&x, &y);
|
|
mLastMouseX = x;
|
|
mLastMouseY = y;
|
|
if (mMediaSource)
|
|
{
|
|
mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOUBLE_CLICK, button, x, y, mask);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::scrollWheel(S32 x, S32 y, MASK mask)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
scaleMouse(&x, &y);
|
|
mLastMouseX = x;
|
|
mLastMouseY = y;
|
|
if (mMediaSource)
|
|
{
|
|
mMediaSource->scrollEvent(x, y, mask);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::onMouseCaptureLost()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
{
|
|
mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, 0, mLastMouseX, mLastMouseY, 0);
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
BOOL LLViewerMediaImpl::handleMouseUp(S32 x, S32 y, MASK mask)
|
|
{
|
|
// NOTE: this is called when the mouse is released when we have capture.
|
|
// Due to the way mouse coordinates are mapped to the object, we can't use the x and y coordinates that come in with the event.
|
|
|
|
if(hasMouseCapture())
|
|
{
|
|
// Release the mouse -- this will also send a mouseup to the media
|
|
gFocusMgr.setMouseCapture( FALSE );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::updateJavascriptObject()
|
|
{
|
|
static LLFrameTimer timer ;
|
|
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if ( mMediaSource )
|
|
{
|
|
// flag to expose this information to internal browser or not.
|
|
static LLCachedControl<bool> enable(gSavedSettings, "BrowserEnableJSObject", false);
|
|
|
|
if(!enable)
|
|
{
|
|
return ; //no need to go further.
|
|
}
|
|
|
|
if(timer.getElapsedTimeF32() < 1.0f)
|
|
{
|
|
return ; //do not update more than once per second.
|
|
}
|
|
timer.reset() ;
|
|
|
|
mMediaSource->jsEnableObject( enable );
|
|
|
|
// these values are only menaingful after login so don't set them before
|
|
//bool logged_in = LLLoginInstance::getInstance()->authSuccess();
|
|
bool logged_in = (LLStartUp::getStartupState() >= STATE_STARTED);
|
|
if ( logged_in )
|
|
{
|
|
// current location within a region
|
|
LLVector3 agent_pos = gAgent.getPositionAgent();
|
|
double x = agent_pos.mV[ VX ];
|
|
double y = agent_pos.mV[ VY ];
|
|
double z = agent_pos.mV[ VZ ];
|
|
mMediaSource->jsAgentLocationEvent( x, y, z );
|
|
|
|
// current location within the grid
|
|
LLVector3d agent_pos_global = gAgent.getLastPositionGlobal();
|
|
double global_x = agent_pos_global.mdV[ VX ];
|
|
double global_y = agent_pos_global.mdV[ VY ];
|
|
double global_z = agent_pos_global.mdV[ VZ ];
|
|
mMediaSource->jsAgentGlobalLocationEvent( global_x, global_y, global_z );
|
|
|
|
// current agent orientation
|
|
double rotation = atan2( gAgent.getAtAxis().mV[VX], gAgent.getAtAxis().mV[VY] );
|
|
double angle = rotation * RAD_TO_DEG;
|
|
if ( angle < 0.0f ) angle = 360.0f + angle; // TODO: has to be a better way to get orientation!
|
|
mMediaSource->jsAgentOrientationEvent( angle );
|
|
|
|
// current region agent is in
|
|
std::string region_name("");
|
|
LLViewerRegion* region = gAgent.getRegion();
|
|
if ( region )
|
|
{
|
|
region_name = region->getName();
|
|
};
|
|
mMediaSource->jsAgentRegionEvent( region_name );
|
|
}
|
|
|
|
// language code the viewer is set to
|
|
mMediaSource->jsAgentLanguageEvent( LLUI::getLanguage() );
|
|
|
|
// maturity setting the agent has selected
|
|
if ( gAgent.prefersAdult() )
|
|
mMediaSource->jsAgentMaturityEvent( "GMA" ); // Adult means see adult, mature and general content
|
|
else
|
|
if ( gAgent.prefersMature() )
|
|
mMediaSource->jsAgentMaturityEvent( "GM" ); // Mature means see mature and general content
|
|
else
|
|
if ( gAgent.prefersPG() )
|
|
mMediaSource->jsAgentMaturityEvent( "G" ); // PG means only see General content
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
const std::string& LLViewerMediaImpl::getName() const
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
{
|
|
return mMediaSource->getMediaName();
|
|
}
|
|
|
|
return LLStringUtil::null;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::navigateBack()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
{
|
|
mMediaSource->browse_back();
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::navigateForward()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
{
|
|
mMediaSource->browse_forward();
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::navigateReload()
|
|
{
|
|
navigateTo(getCurrentMediaURL(), "", true, false);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::navigateHome()
|
|
{
|
|
bool rediscover_mimetype = mHomeMimeType.empty();
|
|
navigateTo(mHomeURL, mHomeMimeType, rediscover_mimetype, false);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::unload()
|
|
{
|
|
// Unload the media impl and clear its state.
|
|
destroyMediaSource();
|
|
resetPreviousMediaState();
|
|
mMediaURL.clear();
|
|
mMimeType.clear();
|
|
mCurrentMediaURL.clear();
|
|
mCurrentMimeType.clear();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::navigateTo(const std::string& url, const std::string& mime_type, bool rediscover_type, bool server_request)
|
|
{
|
|
if (url.empty())
|
|
{
|
|
LL_WARNS() << "Calling LLViewerMediaImpl::navigateTo with empty url" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
cancelMimeTypeProbe();
|
|
|
|
if(mMediaURL != url)
|
|
{
|
|
// Don't carry media play state across distinct URLs.
|
|
resetPreviousMediaState();
|
|
}
|
|
|
|
// Always set the current URL and MIME type.
|
|
mMediaURL = url;
|
|
mMimeType = mime_type;
|
|
|
|
// Clear the current media URL, since it will no longer be correct.
|
|
mCurrentMediaURL.clear();
|
|
|
|
// if mime type discovery was requested, we'll need to do it when the media loads
|
|
mNavigateRediscoverType = rediscover_type;
|
|
|
|
// and if this was a server request, the navigate on load will also need to be one.
|
|
mNavigateServerRequest = server_request;
|
|
|
|
// An explicit navigate resets the "failed" flag.
|
|
mMediaSourceFailed = false;
|
|
|
|
if(mPriority == PRIORITY_UNLOADED)
|
|
{
|
|
// Helpful to have media urls in log file. Shouldn't be spammy.
|
|
{
|
|
// Do not log the query parts
|
|
LLURI u(url);
|
|
std::string sanitized_url = (u.query().empty() ? url : u.scheme() + "://" + u.authority() + u.path());
|
|
LL_INFOS() << "NOT LOADING media id= " << mTextureId << " url=" << sanitized_url << ", mime_type=" << mime_type << LL_ENDL;
|
|
}
|
|
|
|
// This impl should not be loaded at this time.
|
|
LL_DEBUGS("PluginPriority") << this << "Not loading (PRIORITY_UNLOADED)" << LL_ENDL;
|
|
|
|
return;
|
|
}
|
|
|
|
navigateInternal();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::navigateInternal()
|
|
{
|
|
// Helpful to have media urls in log file. Shouldn't be spammy.
|
|
{
|
|
// Do not log the query parts
|
|
LLURI u(mMediaURL);
|
|
std::string sanitized_url = (u.query().empty() ? mMediaURL : u.scheme() + "://" + u.authority() + u.path());
|
|
LL_INFOS() << "media id= " << mTextureId << " url=" << sanitized_url << ", mime_type=" << mMimeType << LL_ENDL;
|
|
}
|
|
|
|
if (mMediaURL.empty())
|
|
{
|
|
LL_WARNS() << "Calling LLViewerMediaImpl::navigateInternal() with empty mMediaURL" << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
if(mNavigateSuspended)
|
|
{
|
|
LL_WARNS() << "Deferring navigate." << LL_ENDL;
|
|
mNavigateSuspendedDeferred = true;
|
|
return;
|
|
}
|
|
|
|
if(mMimeTypeProbe != NULL)
|
|
{
|
|
LL_WARNS() << "MIME type probe already in progress -- bailing out." << LL_ENDL;
|
|
return;
|
|
}
|
|
|
|
if(mNavigateServerRequest)
|
|
{
|
|
setNavState(MEDIANAVSTATE_SERVER_SENT);
|
|
}
|
|
else
|
|
{
|
|
setNavState(MEDIANAVSTATE_NONE);
|
|
}
|
|
|
|
// If the caller has specified a non-empty MIME type, look that up in our MIME types list.
|
|
// If we have a plugin for that MIME type, use that instead of attempting auto-discovery.
|
|
// This helps in supporting legacy media content where the server the media resides on returns a bogus MIME type
|
|
// but the parcel owner has correctly set the MIME type in the parcel media settings.
|
|
|
|
if(!mMimeType.empty() && (mMimeType != LLMIMETypes::getDefaultMimeType()))
|
|
{
|
|
std::string plugin_basename = LLMIMETypes::implType(mMimeType);
|
|
if(!plugin_basename.empty())
|
|
{
|
|
// We have a plugin for this mime type
|
|
mNavigateRediscoverType = false;
|
|
}
|
|
}
|
|
|
|
if(mNavigateRediscoverType)
|
|
{
|
|
|
|
LLURI uri(mMediaURL);
|
|
std::string scheme = uri.scheme();
|
|
|
|
if(scheme.empty() || "http" == scheme || "https" == scheme)
|
|
{
|
|
// If we don't set an Accept header, LLHTTPClient will add one like this:
|
|
// Accept: application/llsd+xml
|
|
// which is really not what we want.
|
|
AIHTTPHeaders headers;
|
|
headers.addHeader("Accept", "*/*");
|
|
// Allow cookies in the response, to prevent a redirect loop when accessing join.secondlife.com
|
|
headers.addHeader("Cookie", "");
|
|
LLHTTPClient::getHeaderOnly( mMediaURL, new LLMimeDiscoveryResponder(this), headers);
|
|
}
|
|
else if("data" == scheme || "file" == scheme || "about" == scheme)
|
|
{
|
|
// FIXME: figure out how to really discover the type for these schemes
|
|
// We use "data" internally for a text/html url for loading the login screen
|
|
if(initializeMedia("text/html"))
|
|
{
|
|
loadURI();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This catches 'rtsp://' urls
|
|
if(initializeMedia(scheme))
|
|
{
|
|
loadURI();
|
|
}
|
|
}
|
|
}
|
|
else if(initializeMedia(mMimeType))
|
|
{
|
|
loadURI();
|
|
}
|
|
else
|
|
{
|
|
LL_WARNS("Media") << "Couldn't navigate to: " << mMediaURL << " as there is no media type for: " << mMimeType << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::navigateStop()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
mMediaSource->browse_stop();
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::handleKeyHere(KEY key, MASK mask)
|
|
{
|
|
bool result = false;
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
|
|
if (mMediaSource)
|
|
{
|
|
// FIXME: THIS IS SO WRONG.
|
|
// Menu keys should be handled by the menu system and not passed to UI elements, but this is how LLTextEditor and LLLineEditor do it...
|
|
if (MASK_CONTROL & mask && key != KEY_LEFT && key != KEY_RIGHT && key != KEY_HOME && key != KEY_END)
|
|
{
|
|
result = true;
|
|
}
|
|
|
|
if( MASK_CONTROL & mask )
|
|
{
|
|
if('C' == key)
|
|
{
|
|
mMediaSource->copy();
|
|
result = true;
|
|
}
|
|
else if('V' == key)
|
|
{
|
|
mMediaSource->paste();
|
|
result = true;
|
|
}
|
|
else if('X' == key)
|
|
{
|
|
mMediaSource->cut();
|
|
result = true;
|
|
}
|
|
}
|
|
|
|
// Singu Note: At the very least, let's allow the login menu to function
|
|
extern LLMenuBarGL* gLoginMenuBarView;
|
|
if (gLoginMenuBarView && gLoginMenuBarView->getVisible() && gLoginMenuBarView->handleAcceleratorKey(key, mask))
|
|
return true;
|
|
|
|
if(!result)
|
|
{
|
|
LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData();
|
|
result = mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_DOWN, key, mask, native_key_data);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::handleKeyUpHere(KEY key, MASK mask)
|
|
{
|
|
bool result = false;
|
|
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
|
|
if (mMediaSource)
|
|
{
|
|
// FIXME: THIS IS SO WRONG.
|
|
// Menu keys should be handled by the menu system and not passed to UI elements, but this is how LLTextEditor and LLLineEditor do it...
|
|
if (MASK_CONTROL & mask && key != KEY_LEFT && key != KEY_RIGHT && key != KEY_HOME && key != KEY_END)
|
|
{
|
|
result = true;
|
|
}
|
|
|
|
if (!result)
|
|
{
|
|
LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData();
|
|
result = mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_UP, key, mask, native_key_data);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::handleUnicodeCharHere(llwchar uni_char)
|
|
{
|
|
bool result = false;
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
|
|
if (mMediaSource)
|
|
{
|
|
// only accept 'printable' characters, sigh...
|
|
if (uni_char >= 32 // discard 'control' characters
|
|
&& uni_char != 127) // SDL thinks this is 'delete' - yuck.
|
|
{
|
|
LLSD native_key_data = gViewerWindow->getWindow()->getNativeKeyData();
|
|
|
|
mMediaSource->textInput(wstring_to_utf8str(LLWString(1, uni_char)), gKeyboard->currentMask(FALSE), native_key_data);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::canNavigateForward()
|
|
{
|
|
BOOL result = FALSE;
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
{
|
|
result = mMediaSource->getHistoryForwardAvailable();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::canNavigateBack()
|
|
{
|
|
BOOL result = FALSE;
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
{
|
|
result = mMediaSource->getHistoryBackAvailable();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
static LLFastTimer::DeclareTimer FTM_MEDIA_DO_UPDATE("Do Update");
|
|
static LLFastTimer::DeclareTimer FTM_MEDIA_GET_DATA("Get Data");
|
|
static LLFastTimer::DeclareTimer FTM_MEDIA_SET_SUBIMAGE("Set Subimage");
|
|
|
|
|
|
void LLViewerMediaImpl::update()
|
|
{
|
|
LLFastTimer t(FTM_MEDIA_DO_UPDATE);
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource == NULL)
|
|
{
|
|
if(mPriority == PRIORITY_UNLOADED)
|
|
{
|
|
// This media source should not be loaded.
|
|
}
|
|
else if(mPriority <= PRIORITY_SLIDESHOW)
|
|
{
|
|
// Don't load new instances that are at PRIORITY_SLIDESHOW or below. They're just kept around to preserve state.
|
|
}
|
|
else if(mMimeTypeProbe != NULL)
|
|
{
|
|
// this media source is doing a MIME type probe -- don't try loading it again.
|
|
}
|
|
else
|
|
{
|
|
// This media may need to be loaded.
|
|
if(sMediaCreateTimer.hasExpired())
|
|
{
|
|
LL_DEBUGS("PluginPriority") << this << ": creating media based on timer expiration" << LL_ENDL;
|
|
createMediaSource();
|
|
sMediaCreateTimer.setTimerExpirySec(LLVIEWERMEDIA_CREATE_DELAY);
|
|
}
|
|
else
|
|
{
|
|
LL_DEBUGS("PluginPriority") << this << ": NOT creating media (waiting on timer)" << LL_ENDL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
updateVolume();
|
|
|
|
// TODO: this is updated every frame - is this bad?
|
|
updateJavascriptObject();
|
|
|
|
// If we didn't just create the impl, it may need to get cookie updates.
|
|
if(!sUpdatedCookies.empty())
|
|
{
|
|
// TODO: Only send cookies to plugins that need them
|
|
mMediaSource->set_cookies(sUpdatedCookies);
|
|
}
|
|
}
|
|
|
|
|
|
if(mMediaSource == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Make sure a navigate doesn't happen during the idle -- it can cause mMediaSource to get destroyed, which can cause a crash.
|
|
setNavigateSuspended(true);
|
|
|
|
mMediaSource->idle();
|
|
|
|
setNavigateSuspended(false);
|
|
|
|
mMediaSource = getMediaPlugin();
|
|
if(mMediaSource == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(mMediaSource->isPluginExited())
|
|
{
|
|
resetPreviousMediaState();
|
|
destroyMediaSource();
|
|
return;
|
|
}
|
|
|
|
if(!mMediaSource->textureValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
if(mSuspendUpdates || !mVisible)
|
|
{
|
|
return;
|
|
}
|
|
|
|
LLViewerMediaTexture* placeholder_image = updatePlaceholderImage();
|
|
|
|
if(placeholder_image)
|
|
{
|
|
LLRect dirty_rect;
|
|
|
|
// Since we're updating this texture, we know it's playing. Tell the texture to do its replacement magic so it gets rendered.
|
|
placeholder_image->setPlaying(TRUE);
|
|
|
|
if(mMediaSource->getDirty(&dirty_rect))
|
|
{
|
|
// Constrain the dirty rect to be inside the texture
|
|
S32 x_pos = llmax(dirty_rect.mLeft, 0);
|
|
S32 y_pos = llmax(dirty_rect.mBottom, 0);
|
|
S32 width = llmin(dirty_rect.mRight, placeholder_image->getWidth()) - x_pos;
|
|
S32 height = llmin(dirty_rect.mTop, placeholder_image->getHeight()) - y_pos;
|
|
|
|
if(width > 0 && height > 0)
|
|
{
|
|
|
|
U8* data = NULL;
|
|
{
|
|
LLFastTimer t(FTM_MEDIA_GET_DATA);
|
|
data = mMediaSource->getBitsData();
|
|
}
|
|
|
|
// Offset the pixels pointer to match x_pos and y_pos
|
|
data += ( x_pos * mMediaSource->getTextureDepth() * mMediaSource->getBitsWidth() );
|
|
data += ( y_pos * mMediaSource->getTextureDepth() );
|
|
|
|
{
|
|
LLFastTimer t(FTM_MEDIA_SET_SUBIMAGE);
|
|
placeholder_image->setSubImage(
|
|
data,
|
|
mMediaSource->getBitsWidth(),
|
|
mMediaSource->getBitsHeight(),
|
|
x_pos,
|
|
y_pos,
|
|
width,
|
|
height,
|
|
TRUE); // <alchemy/>
|
|
}
|
|
|
|
}
|
|
|
|
mMediaSource->resetDirty();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::updateImagesMediaStreams()
|
|
{
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
LLViewerMediaTexture* LLViewerMediaImpl::updatePlaceholderImage()
|
|
{
|
|
if(mTextureId.isNull())
|
|
{
|
|
// The code that created this instance will read from the plugin's bits.
|
|
return NULL;
|
|
}
|
|
|
|
LLViewerMediaTexture* placeholder_image = LLViewerTextureManager::getMediaTexture( mTextureId );
|
|
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
|
|
if (mNeedsNewTexture
|
|
|| placeholder_image->getUseMipMaps()
|
|
|| (placeholder_image->getWidth() != mMediaSource->getTextureWidth())
|
|
|| (placeholder_image->getHeight() != mMediaSource->getTextureHeight())
|
|
|| (mTextureUsedWidth != mMediaSource->getWidth())
|
|
|| (mTextureUsedHeight != mMediaSource->getHeight())
|
|
)
|
|
{
|
|
LL_DEBUGS("Media") << "initializing media placeholder" << LL_ENDL;
|
|
LL_DEBUGS("Media") << "movie image id " << mTextureId << LL_ENDL;
|
|
|
|
int texture_width = mMediaSource->getTextureWidth();
|
|
int texture_height = mMediaSource->getTextureHeight();
|
|
int texture_depth = mMediaSource->getTextureDepth();
|
|
|
|
// MEDIAOPT: check to see if size actually changed before doing work
|
|
placeholder_image->destroyGLTexture();
|
|
// MEDIAOPT: apparently just calling setUseMipMaps(FALSE) doesn't work?
|
|
placeholder_image->reinit(FALSE); // probably not needed
|
|
|
|
// MEDIAOPT: seems insane that we actually have to make an imageraw then
|
|
// immediately discard it
|
|
LLPointer<LLImageRaw> raw = new LLImageRaw(texture_width, texture_height, texture_depth);
|
|
// Clear the texture to the background color, ignoring alpha.
|
|
// convert background color channels from [0.0, 1.0] to [0, 255];
|
|
raw->clear(int(mBackgroundColor.mV[VX] * 255.0f), int(mBackgroundColor.mV[VY] * 255.0f), int(mBackgroundColor.mV[VZ] * 255.0f), 0xff);
|
|
int discard_level = 0;
|
|
|
|
// ask media source for correct GL image format constants
|
|
placeholder_image->setExplicitFormat(mMediaSource->getTextureFormatInternal(),
|
|
mMediaSource->getTextureFormatPrimary(),
|
|
mMediaSource->getTextureFormatType(),
|
|
mMediaSource->getTextureFormatSwapBytes());
|
|
|
|
placeholder_image->createGLTexture(discard_level, raw);
|
|
|
|
// MEDIAOPT: set this dynamically on play/stop
|
|
// FIXME
|
|
// placeholder_image->mIsMediaTexture = true;
|
|
mNeedsNewTexture = false;
|
|
|
|
// If the amount of the texture being drawn by the media goes down in either width or height,
|
|
// recreate the texture to avoid leaving parts of the old image behind.
|
|
mTextureUsedWidth = mMediaSource->getWidth();
|
|
mTextureUsedHeight = mMediaSource->getHeight();
|
|
}
|
|
|
|
return placeholder_image;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
LLUUID LLViewerMediaImpl::getMediaTextureID() const
|
|
{
|
|
return mTextureId;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::setVisible(bool visible)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
mVisible = visible;
|
|
|
|
if(mVisible)
|
|
{
|
|
if(mMediaSource && mMediaSource->isPluginExited())
|
|
{
|
|
destroyMediaSource();
|
|
mMediaSource = NULL;
|
|
}
|
|
|
|
if(!mMediaSource)
|
|
{
|
|
createMediaSource();
|
|
}
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::mouseCapture()
|
|
{
|
|
gFocusMgr.setMouseCapture(this);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::scaleMouse(S32 *mouse_x, S32 *mouse_y)
|
|
{
|
|
#if 0
|
|
S32 media_width, media_height;
|
|
S32 texture_width, texture_height;
|
|
getMediaSize( &media_width, &media_height );
|
|
getTextureSize( &texture_width, &texture_height );
|
|
S32 y_delta = texture_height - media_height;
|
|
|
|
*mouse_y -= y_delta;
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::isMediaTimeBased()
|
|
{
|
|
bool result = false;
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
|
|
if(mMediaSource)
|
|
{
|
|
result = mMediaSource->pluginSupportsMediaTime();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::isMediaPlaying()
|
|
{
|
|
bool result = false;
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
|
|
if(mMediaSource)
|
|
{
|
|
EMediaStatus status = mMediaSource->getStatus();
|
|
if(status == MEDIA_PLAYING || status == MEDIA_LOADING)
|
|
result = true;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
bool LLViewerMediaImpl::isMediaPaused()
|
|
{
|
|
bool result = false;
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
|
|
if(mMediaSource)
|
|
{
|
|
if(mMediaSource->getStatus() == MEDIA_PAUSED)
|
|
result = true;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
bool LLViewerMediaImpl::hasMedia() const
|
|
{
|
|
return mPluginBase != NULL;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
void LLViewerMediaImpl::resetPreviousMediaState()
|
|
{
|
|
mPreviousMediaState = MEDIA_NONE;
|
|
mPreviousMediaTime = 0.0f;
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
void LLViewerMediaImpl::setDisabled(bool disabled, bool forcePlayOnEnable)
|
|
{
|
|
if(mIsDisabled != disabled)
|
|
{
|
|
// Only do this on actual state transitions.
|
|
mIsDisabled = disabled;
|
|
|
|
if(mIsDisabled)
|
|
{
|
|
// We just disabled this media. Clear all state.
|
|
unload();
|
|
}
|
|
else
|
|
{
|
|
// We just (re)enabled this media. Do a navigate if auto-play is in order.
|
|
if(isAutoPlayable() || forcePlayOnEnable)
|
|
{
|
|
navigateTo(mMediaEntryURL, "", true, true);
|
|
}
|
|
}
|
|
|
|
}
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
bool LLViewerMediaImpl::isForcedUnloaded() const
|
|
{
|
|
if(mIsMuted || mMediaSourceFailed || mIsDisabled)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// If this media's class is not supposed to be shown, unload
|
|
if (!shouldShowBasedOnClass())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
bool LLViewerMediaImpl::isPlayable() const
|
|
{
|
|
if(isForcedUnloaded())
|
|
{
|
|
// All of the forced-unloaded criteria also imply not playable.
|
|
return false;
|
|
}
|
|
|
|
if(hasMedia())
|
|
{
|
|
// Anything that's already playing is, by definition, playable.
|
|
return true;
|
|
}
|
|
|
|
if(!mMediaURL.empty())
|
|
{
|
|
// If something has navigated the instance, it's ready to be played.
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void handle_pick_file_request_continued(LLPluginClassMedia* plugin, AIFilePicker* filepicker)
|
|
{
|
|
plugin->sendPickFileResponse(filepicker->hasFilename() ? filepicker->getFilename() : LLStringUtil::null);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* plugin, LLPluginClassMediaOwner::EMediaEvent event)
|
|
{
|
|
bool pass_through = true;
|
|
switch(event)
|
|
{
|
|
case MEDIA_EVENT_CLICK_LINK_NOFOLLOW:
|
|
{
|
|
LL_DEBUGS("Media") << "MEDIA_EVENT_CLICK_LINK_NOFOLLOW, uri is: " << plugin->getClickURL() << LL_ENDL;
|
|
std::string url = plugin->getClickURL();
|
|
std::string nav_type = plugin->getClickNavType();
|
|
LLURLDispatcher::dispatch(url, nav_type, NULL, mTrustedBrowser);
|
|
}
|
|
break;
|
|
case MEDIA_EVENT_CLICK_LINK_HREF:
|
|
{
|
|
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CLICK_LINK_HREF, target is \"" << plugin->getClickTarget() << "\", uri is " << plugin->getClickURL() << LL_ENDL;
|
|
};
|
|
break;
|
|
case MEDIA_EVENT_PLUGIN_FAILED_LAUNCH:
|
|
{
|
|
// The plugin failed to load properly. Make sure the timer doesn't retry.
|
|
// TODO: maybe mark this plugin as not loadable somehow?
|
|
mMediaSourceFailed = true;
|
|
|
|
// Reset the last known state of the media to defaults.
|
|
resetPreviousMediaState();
|
|
|
|
// TODO: may want a different message for this case?
|
|
LLSD args;
|
|
args["PLUGIN"] = LLMIMETypes::implType(mCurrentMimeType);
|
|
LLNotificationsUtil::add("MediaPluginFailed", args);
|
|
}
|
|
break;
|
|
|
|
case MEDIA_EVENT_PLUGIN_FAILED:
|
|
{
|
|
// The plugin crashed.
|
|
mMediaSourceFailed = true;
|
|
|
|
// Reset the last known state of the media to defaults.
|
|
resetPreviousMediaState();
|
|
|
|
LLSD args;
|
|
args["PLUGIN"] = LLMIMETypes::implType(mCurrentMimeType);
|
|
// SJB: This is getting called every frame if the plugin fails to load, continuously respawining the alert!
|
|
//LLNotificationsUtil::add("MediaPluginFailed", args);
|
|
}
|
|
break;
|
|
|
|
case MEDIA_EVENT_CURSOR_CHANGED:
|
|
{
|
|
LL_DEBUGS("Media") << "Media event: MEDIA_EVENT_CURSOR_CHANGED, new cursor is " << plugin->getCursorName() << LL_ENDL;
|
|
|
|
std::string cursor = plugin->getCursorName();
|
|
|
|
if(cursor == "arrow")
|
|
mLastSetCursor = UI_CURSOR_ARROW;
|
|
else if(cursor == "ibeam")
|
|
mLastSetCursor = UI_CURSOR_IBEAM;
|
|
else if(cursor == "splith")
|
|
mLastSetCursor = UI_CURSOR_SIZEWE;
|
|
else if(cursor == "splitv")
|
|
mLastSetCursor = UI_CURSOR_SIZENS;
|
|
else if(cursor == "hand")
|
|
mLastSetCursor = UI_CURSOR_HAND;
|
|
else // for anything else, default to the arrow
|
|
mLastSetCursor = UI_CURSOR_ARROW;
|
|
}
|
|
break;
|
|
|
|
case LLViewerMediaObserver::MEDIA_EVENT_NAVIGATE_BEGIN:
|
|
{
|
|
LL_DEBUGS("Media") << "MEDIA_EVENT_NAVIGATE_BEGIN, uri is: " << plugin->getNavigateURI() << LL_ENDL;
|
|
hideNotification();
|
|
|
|
if(getNavState() == MEDIANAVSTATE_SERVER_SENT)
|
|
{
|
|
setNavState(MEDIANAVSTATE_SERVER_BEGUN);
|
|
}
|
|
else
|
|
{
|
|
setNavState(MEDIANAVSTATE_BEGUN);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case LLViewerMediaObserver::MEDIA_EVENT_NAVIGATE_COMPLETE:
|
|
{
|
|
LL_DEBUGS("Media") << "MEDIA_EVENT_NAVIGATE_COMPLETE, uri is: " << plugin->getNavigateURI() << LL_ENDL;
|
|
|
|
std::string url = plugin->getNavigateURI();
|
|
if(getNavState() == MEDIANAVSTATE_BEGUN)
|
|
{
|
|
if(mCurrentMediaURL == url)
|
|
{
|
|
// This is a navigate that takes us to the same url as the previous navigate.
|
|
setNavState(MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS);
|
|
}
|
|
else
|
|
{
|
|
mCurrentMediaURL = url;
|
|
setNavState(MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED);
|
|
}
|
|
}
|
|
else if(getNavState() == MEDIANAVSTATE_SERVER_BEGUN)
|
|
{
|
|
mCurrentMediaURL = url;
|
|
setNavState(MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED);
|
|
}
|
|
else
|
|
{
|
|
// all other cases need to leave the state alone.
|
|
}
|
|
}
|
|
break;
|
|
|
|
case LLViewerMediaObserver::MEDIA_EVENT_LOCATION_CHANGED:
|
|
{
|
|
LL_DEBUGS("Media") << "MEDIA_EVENT_LOCATION_CHANGED, uri is: " << plugin->getLocation() << LL_ENDL;
|
|
|
|
std::string url = plugin->getLocation();
|
|
|
|
if(getNavState() == MEDIANAVSTATE_BEGUN)
|
|
{
|
|
if(mCurrentMediaURL == url)
|
|
{
|
|
// This is a navigate that takes us to the same url as the previous navigate.
|
|
setNavState(MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS);
|
|
}
|
|
else
|
|
{
|
|
mCurrentMediaURL = url;
|
|
setNavState(MEDIANAVSTATE_FIRST_LOCATION_CHANGED);
|
|
}
|
|
}
|
|
else if(getNavState() == MEDIANAVSTATE_SERVER_BEGUN)
|
|
{
|
|
mCurrentMediaURL = url;
|
|
setNavState(MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED);
|
|
}
|
|
else
|
|
{
|
|
// Don't track redirects.
|
|
setNavState(MEDIANAVSTATE_NONE);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case LLViewerMediaObserver::MEDIA_EVENT_PICK_FILE_REQUEST:
|
|
{
|
|
AIFilePicker* filepicker = AIFilePicker::create();
|
|
filepicker->open(FFLOAD_ALL, "", "openfile", true);
|
|
filepicker->run(boost::bind(&handle_pick_file_request_continued, plugin, filepicker));
|
|
// Display a file picker
|
|
//std::string response;
|
|
|
|
/*LLFilePicker& picker = LLFilePicker::instance();
|
|
if (!picker.getOpenFile(LLFilePicker::FFLOAD_ALL))
|
|
{
|
|
// The user didn't pick a file -- the empty response string will indicate this.
|
|
}
|
|
|
|
response = picker.getFirstFile();
|
|
|
|
plugin->sendPickFileResponse(response);*/
|
|
}
|
|
break;
|
|
|
|
|
|
case LLViewerMediaObserver::MEDIA_EVENT_AUTH_REQUEST:
|
|
{
|
|
LLNotification::Params auth_request_params("AuthRequest");
|
|
|
|
// pass in host name and realm for site (may be zero length but will always exist)
|
|
LLSD args;
|
|
LLURL raw_url( plugin->getAuthURL().c_str() );
|
|
args["HOST_NAME"] = raw_url.getAuthority();
|
|
args["REALM"] = plugin->getAuthRealm();
|
|
auth_request_params.substitutions = args;
|
|
|
|
auth_request_params.payload = LLSD().with("media_id", mTextureId);
|
|
auth_request_params.functor(boost::bind(&LLViewerMedia::onAuthSubmit, _1, _2));
|
|
LLNotifications::instance().add(auth_request_params);
|
|
};
|
|
break;
|
|
|
|
case LLViewerMediaObserver::MEDIA_EVENT_CLOSE_REQUEST:
|
|
{
|
|
std::string uuid = plugin->getClickUUID();
|
|
|
|
LL_INFOS() << "MEDIA_EVENT_CLOSE_REQUEST for uuid " << uuid << LL_ENDL;
|
|
|
|
if(uuid.empty())
|
|
{
|
|
// This close request is directed at this instance, let it fall through.
|
|
}
|
|
else
|
|
{
|
|
// This close request is directed at another instance
|
|
pass_through = false;
|
|
LLFloaterWebContent::closeRequest(uuid);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case LLViewerMediaObserver::MEDIA_EVENT_GEOMETRY_CHANGE:
|
|
{
|
|
std::string uuid = plugin->getClickUUID();
|
|
|
|
LL_INFOS() << "MEDIA_EVENT_GEOMETRY_CHANGE for uuid " << uuid << LL_ENDL;
|
|
|
|
if(uuid.empty())
|
|
{
|
|
// This geometry change request is directed at this instance, let it fall through.
|
|
}
|
|
else
|
|
{
|
|
// This request is directed at another instance
|
|
pass_through = false;
|
|
LLFloaterWebContent::geometryChanged(uuid, plugin->getGeometryX(), plugin->getGeometryY(), plugin->getGeometryWidth(), plugin->getGeometryHeight());
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if(pass_through)
|
|
{
|
|
// Just chain the event to observers.
|
|
emitEvent(plugin, event);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// virtual
|
|
void LLViewerMediaImpl::handleCookieSet(LLPluginClassMedia* self, const std::string &cookie)
|
|
{
|
|
LLViewerMedia::getCookieStore()->setCookies(cookie);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// virtual
|
|
void
|
|
LLViewerMediaImpl::cut()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
mMediaSource->cut();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// virtual
|
|
BOOL
|
|
LLViewerMediaImpl::canCut() const
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
return mMediaSource->canCut();
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// virtual
|
|
void
|
|
LLViewerMediaImpl::copy()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
mMediaSource->copy();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// virtual
|
|
BOOL
|
|
LLViewerMediaImpl::canCopy() const
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
return mMediaSource->canCopy();
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// virtual
|
|
void
|
|
LLViewerMediaImpl::paste()
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
mMediaSource->paste();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// virtual
|
|
BOOL
|
|
LLViewerMediaImpl::canPaste() const
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if (mMediaSource)
|
|
return mMediaSource->canPaste();
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
void LLViewerMediaImpl::setUpdated(BOOL updated)
|
|
{
|
|
mIsUpdated = updated ;
|
|
}
|
|
|
|
BOOL LLViewerMediaImpl::isUpdated()
|
|
{
|
|
return mIsUpdated ;
|
|
}
|
|
|
|
static LLFastTimer::DeclareTimer FTM_MEDIA_CALCULATE_INTEREST("Calculate Interest");
|
|
|
|
void LLViewerMediaImpl::calculateInterest()
|
|
{
|
|
LLFastTimer t(FTM_MEDIA_CALCULATE_INTEREST);
|
|
LLViewerMediaTexture* texture = LLViewerTextureManager::findMediaTexture( mTextureId );
|
|
|
|
if(texture != NULL)
|
|
{
|
|
mInterest = texture->getMaxVirtualSize();
|
|
}
|
|
else
|
|
{
|
|
// This will be a relatively common case now, since it will always be true for unloaded media.
|
|
mInterest = 0.0f;
|
|
}
|
|
|
|
// Calculate distance from the avatar, for use in the proximity calculation.
|
|
mProximityDistance = 0.0f;
|
|
mProximityCamera = 0.0f;
|
|
if(!mObjectList.empty())
|
|
{
|
|
// Just use the first object in the list. We could go through the list and find the closest object, but this should work well enough.
|
|
std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
|
|
LLVOVolume* objp = *iter ;
|
|
llassert_always(objp != NULL) ;
|
|
|
|
// The distance calculation is invalid for HUD attachments -- leave both mProximityDistance and mProximityCamera at 0 for them.
|
|
if(!objp->isHUDAttachment())
|
|
{
|
|
LLVector3d obj_global = objp->getPositionGlobal() ;
|
|
LLVector3d agent_global = gAgent.getPositionGlobal() ;
|
|
LLVector3d global_delta = agent_global - obj_global ;
|
|
mProximityDistance = global_delta.magVecSquared(); // use distance-squared because it's cheaper and sorts the same.
|
|
|
|
LLVector3d camera_delta = gAgentCamera.getCameraPositionGlobal() - obj_global;
|
|
mProximityCamera = camera_delta.magVec();
|
|
}
|
|
}
|
|
|
|
if(mNeedsMuteCheck)
|
|
{
|
|
// Check all objects this instance is associated with, and those objects' owners, against the mute list
|
|
mIsMuted = false;
|
|
|
|
std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
|
|
for(; iter != mObjectList.end() ; ++iter)
|
|
{
|
|
LLVOVolume *obj = *iter;
|
|
llassert(obj);
|
|
if (!obj) continue;
|
|
if(LLMuteList::getInstance() &&
|
|
LLMuteList::getInstance()->isMuted(obj->getID()))
|
|
{
|
|
mIsMuted = true;
|
|
}
|
|
else
|
|
{
|
|
// We won't have full permissions data for all objects. Attempt to mute objects when we can tell their owners are muted.
|
|
if (LLSelectMgr::getInstance())
|
|
{
|
|
LLPermissions* obj_perm = LLSelectMgr::getInstance()->findObjectPermissions(obj);
|
|
if(obj_perm)
|
|
{
|
|
if(LLMuteList::getInstance() &&
|
|
LLMuteList::getInstance()->isMuted(obj_perm->getOwner()))
|
|
mIsMuted = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
mNeedsMuteCheck = false;
|
|
}
|
|
}
|
|
|
|
F64 LLViewerMediaImpl::getApproximateTextureInterest()
|
|
{
|
|
F64 result = 0.0f;
|
|
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
result = mMediaSource->getFullWidth();
|
|
result *= mMediaSource->getFullHeight();
|
|
}
|
|
else
|
|
{
|
|
// No media source is loaded -- all we have to go on is the texture size that has been set on the impl, if any.
|
|
result = mMediaWidth;
|
|
result *= mMediaHeight;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void LLViewerMediaImpl::setUsedInUI(bool used_in_ui)
|
|
{
|
|
mUsedInUI = used_in_ui;
|
|
|
|
// HACK: Force elements used in UI to load right away.
|
|
// This fixes some issues where UI code that uses the browser instance doesn't expect it to be unloaded.
|
|
if(mUsedInUI && (mPriority == PRIORITY_UNLOADED))
|
|
{
|
|
if(getVisible())
|
|
{
|
|
setPriority(PRIORITY_NORMAL);
|
|
}
|
|
else
|
|
{
|
|
setPriority(PRIORITY_HIDDEN);
|
|
}
|
|
|
|
createMediaSource();
|
|
}
|
|
};
|
|
|
|
void LLViewerMediaImpl::setBackgroundColor(LLColor4 color)
|
|
{
|
|
mBackgroundColor = color;
|
|
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
mMediaSource->setBackgroundColor(mBackgroundColor);
|
|
}
|
|
};
|
|
|
|
F64 LLViewerMediaImpl::getCPUUsage() const
|
|
{
|
|
F64 result = 0.0f;
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
|
|
if(mMediaSource)
|
|
{
|
|
result = mMediaSource->getCPUUsage();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
char const* PRIORITYToString(LLViewerMediaImpl::EPriority priority)
|
|
{
|
|
switch(priority)
|
|
{
|
|
case LLViewerMediaImpl::PRIORITY_UNLOADED: return "unloaded";
|
|
case LLViewerMediaImpl::PRIORITY_HIDDEN: return "hidden";
|
|
case LLViewerMediaImpl::PRIORITY_SLIDESHOW: return "slideshow";
|
|
case LLViewerMediaImpl::PRIORITY_LOW: return "low";
|
|
case LLViewerMediaImpl::PRIORITY_NORMAL: return "normal";
|
|
case LLViewerMediaImpl::PRIORITY_HIGH: return "high";
|
|
default: return "UNKNOWN";
|
|
}
|
|
}
|
|
|
|
void LLViewerMediaImpl::setPriority(EPriority priority)
|
|
{
|
|
if(mPriority != priority)
|
|
{
|
|
LL_DEBUGS("PluginPriority")
|
|
<< "changing priority of media id " << mTextureId
|
|
<< " from " << ::PRIORITYToString(mPriority)
|
|
<< " to " << ::PRIORITYToString(priority)
|
|
<< LL_ENDL;
|
|
}
|
|
|
|
mPriority = priority;
|
|
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(priority == PRIORITY_UNLOADED)
|
|
{
|
|
if(mMediaSource)
|
|
{
|
|
// Need to unload the media source
|
|
|
|
// First, save off previous media state
|
|
mPreviousMediaState = mMediaSource->getStatus();
|
|
mPreviousMediaTime = mMediaSource->getCurrentTime();
|
|
|
|
destroyMediaSource();
|
|
mMediaSource = NULL;
|
|
}
|
|
}
|
|
|
|
if(mMediaSource)
|
|
{
|
|
if(mPriority >= PRIORITY_LOW)
|
|
mMediaSource->setPriority((LLPluginClassBasic::EPriority)((U32)mPriority-((U32)PRIORITY_LOW-1)));
|
|
else
|
|
mMediaSource->setPriority(LLPluginClassBasic::PRIORITY_SLEEP);
|
|
}
|
|
|
|
// NOTE: loading (or reloading) media sources whose priority has risen above PRIORITY_UNLOADED is done in update().
|
|
}
|
|
|
|
void LLViewerMediaImpl::setLowPrioritySizeLimit(int size)
|
|
{
|
|
LLPluginClassMedia* mMediaSource = getMediaPlugin();
|
|
if(mMediaSource)
|
|
{
|
|
mMediaSource->setLowPrioritySizeLimit(size);
|
|
}
|
|
}
|
|
|
|
void LLViewerMediaImpl::setNavState(EMediaNavState state)
|
|
{
|
|
mMediaNavState = state;
|
|
|
|
switch (state)
|
|
{
|
|
case MEDIANAVSTATE_NONE: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_NONE" << LL_ENDL; break;
|
|
case MEDIANAVSTATE_BEGUN: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_BEGUN" << LL_ENDL; break;
|
|
case MEDIANAVSTATE_FIRST_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_FIRST_LOCATION_CHANGED" << LL_ENDL; break;
|
|
case MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_FIRST_LOCATION_CHANGED_SPURIOUS" << LL_ENDL; break;
|
|
case MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED" << LL_ENDL; break;
|
|
case MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_COMPLETE_BEFORE_LOCATION_CHANGED_SPURIOUS" << LL_ENDL; break;
|
|
case MEDIANAVSTATE_SERVER_SENT: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_SENT" << LL_ENDL; break;
|
|
case MEDIANAVSTATE_SERVER_BEGUN: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_BEGUN" << LL_ENDL; break;
|
|
case MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_FIRST_LOCATION_CHANGED" << LL_ENDL; break;
|
|
case MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED: LL_DEBUGS("Media") << "Setting nav state to MEDIANAVSTATE_SERVER_COMPLETE_BEFORE_LOCATION_CHANGED" << LL_ENDL; break;
|
|
}
|
|
}
|
|
|
|
void LLViewerMediaImpl::setNavigateSuspended(bool suspend)
|
|
{
|
|
if(mNavigateSuspended != suspend)
|
|
{
|
|
mNavigateSuspended = suspend;
|
|
if(!suspend)
|
|
{
|
|
// We're coming out of suspend. If someone tried to do a navigate while suspended, do one now instead.
|
|
if(mNavigateSuspendedDeferred)
|
|
{
|
|
mNavigateSuspendedDeferred = false;
|
|
navigateInternal();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLViewerMediaImpl::cancelMimeTypeProbe()
|
|
{
|
|
if(mMimeTypeProbe != NULL)
|
|
{
|
|
// There doesn't seem to be a way to actually cancel an outstanding request.
|
|
// Simulate it by telling the LLMimeDiscoveryResponder not to write back any results.
|
|
mMimeTypeProbe->cancelRequest();
|
|
|
|
// The above should already have set mMimeTypeProbe to NULL.
|
|
if(mMimeTypeProbe != NULL)
|
|
{
|
|
LL_ERRS() << "internal error: mMimeTypeProbe is not NULL after cancelling request." << LL_ENDL;
|
|
}
|
|
}
|
|
}
|
|
|
|
void LLViewerMediaImpl::addObject(LLVOVolume* obj)
|
|
{
|
|
std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
|
|
for(; iter != mObjectList.end() ; ++iter)
|
|
{
|
|
if(*iter == obj)
|
|
{
|
|
return ; //already in the list.
|
|
}
|
|
}
|
|
|
|
mObjectList.push_back(obj) ;
|
|
mNeedsMuteCheck = true;
|
|
}
|
|
|
|
void LLViewerMediaImpl::removeObject(LLVOVolume* obj)
|
|
{
|
|
mObjectList.remove(obj) ;
|
|
mNeedsMuteCheck = true;
|
|
}
|
|
|
|
const std::list< LLVOVolume* >* LLViewerMediaImpl::getObjectList() const
|
|
{
|
|
return &mObjectList ;
|
|
}
|
|
|
|
LLVOVolume *LLViewerMediaImpl::getSomeObject()
|
|
{
|
|
LLVOVolume *result = NULL;
|
|
|
|
std::list< LLVOVolume* >::iterator iter = mObjectList.begin() ;
|
|
if(iter != mObjectList.end())
|
|
{
|
|
result = *iter;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void LLViewerMediaImpl::setTextureID(LLUUID id)
|
|
{
|
|
if(id != mTextureId)
|
|
{
|
|
if(mTextureId.notNull())
|
|
{
|
|
// Remove this item's entry from the map
|
|
sViewerMediaTextureIDMap.erase(mTextureId);
|
|
}
|
|
|
|
if(id.notNull())
|
|
{
|
|
sViewerMediaTextureIDMap.insert(LLViewerMedia::impl_id_map::value_type(id, this));
|
|
}
|
|
|
|
mTextureId = id;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
bool LLViewerMediaImpl::isAutoPlayable() const
|
|
{
|
|
static const LLCachedControl<bool> media_tentative_auto_play("MediaTentativeAutoPlay",false);
|
|
static const LLCachedControl<bool> auto_play_parcel_media(LLViewerMedia::AUTO_PLAY_MEDIA_SETTING,false);
|
|
static const LLCachedControl<bool> auto_play_prim_media(LLViewerMedia::AUTO_PLAY_PRIM_MEDIA_SETTING,false);
|
|
return mMediaAutoPlay && media_tentative_auto_play &&
|
|
(getUsedInUI()
|
|
|| (isParcelMedia() && auto_play_parcel_media)
|
|
|| auto_play_prim_media);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
bool LLViewerMediaImpl::shouldShowBasedOnClass() const
|
|
{
|
|
// If this is parcel media or in the UI, return true always
|
|
if (getUsedInUI() || isParcelMedia()) return true;
|
|
|
|
bool attached_to_another_avatar = isAttachedToAnotherAvatar();
|
|
bool inside_parcel = isInAgentParcel();
|
|
|
|
// LL_INFOS() << " hasFocus = " << hasFocus() <<
|
|
// " others = " << (attached_to_another_avatar && gSavedSettings.getBOOL(LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING)) <<
|
|
// " within = " << (inside_parcel && gSavedSettings.getBOOL(LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING)) <<
|
|
// " outside = " << (!inside_parcel && gSavedSettings.getBOOL(LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING)) << LL_ENDL;
|
|
|
|
// If it has focus, we should show it
|
|
// This is incorrect, and causes EXT-6750 (disabled attachment media still plays)
|
|
// if (hasFocus())
|
|
// return true;
|
|
|
|
// If it is attached to an avatar and the pref is off, we shouldn't show it
|
|
if (attached_to_another_avatar)
|
|
{
|
|
static LLCachedControl<bool> show_media_on_others(gSavedSettings, LLViewerMedia::SHOW_MEDIA_ON_OTHERS_SETTING, false);
|
|
return show_media_on_others;
|
|
}
|
|
if (inside_parcel)
|
|
{
|
|
static LLCachedControl<bool> show_media_within_parcel(gSavedSettings, LLViewerMedia::SHOW_MEDIA_WITHIN_PARCEL_SETTING, true);
|
|
|
|
return show_media_within_parcel;
|
|
}
|
|
else
|
|
{
|
|
static LLCachedControl<bool> show_media_outside_parcel(gSavedSettings, LLViewerMedia::SHOW_MEDIA_OUTSIDE_PARCEL_SETTING, true);
|
|
|
|
return show_media_outside_parcel;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
bool LLViewerMediaImpl::isAttachedToAnotherAvatar() const
|
|
{
|
|
bool result = false;
|
|
|
|
std::list< LLVOVolume* >::const_iterator iter = mObjectList.begin();
|
|
std::list< LLVOVolume* >::const_iterator end = mObjectList.end();
|
|
for ( ; iter != end; iter++)
|
|
{
|
|
if (isObjectAttachedToAnotherAvatar(*iter))
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
//static
|
|
bool LLViewerMediaImpl::isObjectAttachedToAnotherAvatar(LLVOVolume *obj)
|
|
{
|
|
bool result = false;
|
|
LLXform *xform = obj;
|
|
// Walk up parent chain
|
|
while (NULL != xform)
|
|
{
|
|
LLViewerObject *object = dynamic_cast<LLViewerObject*> (xform);
|
|
if (NULL != object)
|
|
{
|
|
LLVOAvatar *avatar = object->asAvatar();
|
|
if ((NULL != avatar) && (avatar != gAgentAvatarp))
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
xform = xform->getParent();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
bool LLViewerMediaImpl::isInAgentParcel() const
|
|
{
|
|
bool result = false;
|
|
|
|
std::list< LLVOVolume* >::const_iterator iter = mObjectList.begin();
|
|
std::list< LLVOVolume* >::const_iterator end = mObjectList.end();
|
|
for ( ; iter != end; iter++)
|
|
{
|
|
LLVOVolume *object = *iter;
|
|
if (LLViewerMediaImpl::isObjectInAgentParcel(object))
|
|
{
|
|
result = true;
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
LLNotificationPtr LLViewerMediaImpl::getCurrentNotification() const
|
|
{
|
|
return mNotification;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// static
|
|
bool LLViewerMediaImpl::isObjectInAgentParcel(LLVOVolume *obj)
|
|
{
|
|
return (LLViewerParcelMgr::getInstance()->inAgentParcel(obj->getPositionGlobal()));
|
|
}
|