1 files changed, 914 insertions, 389 deletions

diff --git a/indra/newview/llviewermedia.cpp b/indra/newview/llviewermedia.cpp
index 21d686a250..c3e6bd28da 100644
--- a/indra/newview/llviewermedia.cpp
+++ b/indra/newview/llviewermedia.cpp
@@ -33,614 +33,1123 @@
 #include "llviewerprecompiledheaders.h"
 
 #include "llviewermedia.h"
-
-#include "audioengine.h"
-
-#include "llparcel.h"
-
+#include "llviewermediafocus.h"
+#include "llhoverview.h"
 #include "llmimetypes.h"
 #include "llviewercontrol.h"
 #include "llviewertexture.h"
 #include "llviewerparcelmedia.h"
 #include "llviewerparcelmgr.h"
-#include "llviewerparcelmedia.h"
-#include "llviewerparcelmgr.h"
 #include "llviewerwindow.h"
 #include "llversionviewer.h"
 #include "llviewertexturelist.h"
+#include "llpluginclassmedia.h"
 
 #include "llevent.h"		// LLSimpleListener
-#include "llmediamanager.h"
 #include "lluuid.h"
 
 #include <boost/bind.hpp>	// for SkinFolder listener
 #include <boost/signals2.hpp>
 
+// Move this to its own file.
 
-// Implementation functions not exported into header file
-class LLViewerMediaImpl
-	:	public LLMediaObserver
+LLViewerMediaEventEmitter::~LLViewerMediaEventEmitter()
 {
-public:
-	LLViewerMediaImpl()
-	:	mMediaSource( NULL ),
-		mMovieImageID(),
-		mMovieImageHasMips(false)
-	{ }
-
-	void destroyMediaSource();
-
-    void play(const std::string& media_url,
-			  const std::string& mime_type,
-			  const LLUUID& placeholder_texture_id,
-			  S32 media_width, S32 media_height, U8 media_auto_scale,
-			  U8 media_loop);
-
-	void stop();
-	void pause();
-	void start();
-	void seek(F32 time);
-	void setVolume(F32 volume);
-	LLMediaBase::EStatus getStatus();
-
-	/*virtual*/ void onMediaSizeChange(const EventType& event_in);
-	/*virtual*/ void onMediaContentsChange(const EventType& event_in);
-
-	void restoreMovieImage();
-	void updateImagesMediaStreams();
-	LLUUID getMediaTextureID();
-
-	// Internally set our desired browser user agent string, including
-	// the Second Life version and skin name.  Used because we can
-	// switch skins without restarting the app.
-	static void updateBrowserUserAgent();
-
-	// Callback for when the SkinCurrent control is changed to
-	// switch the user agent string to indicate the new skin.
-	static bool handleSkinCurrentChanged(const LLSD& newvalue);
+	observerListType::iterator iter = mObservers.begin();
 
-public:
+	while( iter != mObservers.end() )
+	{
+		LLViewerMediaObserver *self = *iter;
+		iter++;
+		remObserver(self);
+	}
+}
 
-	// a single media url with some data and an impl.
-	LLMediaBase* mMediaSource;
-	LLUUID mMovieImageID;
-	bool  mMovieImageHasMips;
-	std::string mMediaURL;
-	std::string mMimeType;
+///////////////////////////////////////////////////////////////////////////////
+//
+bool LLViewerMediaEventEmitter::addObserver( LLViewerMediaObserver* observer )
+{
+	if ( ! observer )
+		return false;
 
-private:
-	void initializePlaceholderImage(LLViewerMediaTexture *placeholder_image, LLMediaBase *media_source);	
-};
+	if ( std::find( mObservers.begin(), mObservers.end(), observer ) != mObservers.end() )
+		return false;
 
-static LLViewerMediaImpl sViewerMediaImpl;
-//////////////////////////////////////////////////////////////////////////////////////////
+	mObservers.push_back( observer );
+	observer->mEmitters.push_back( this );
 
-void LLViewerMediaImpl::destroyMediaSource()
+	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, LLPluginClassMediaOwner::EMediaEvent event )
 {
-	LLMediaManager* mgr = LLMediaManager::getInstance();
-	if ( mMediaSource )
+	observerListType::iterator iter = mObservers.begin();
+
+	while( iter != mObservers.end() )
 	{
-		mMediaSource->remObserver(this);
-		mgr->destroySource( mMediaSource );
+		LLViewerMediaObserver *self = *iter;
+		++iter;
+		self->handleMediaEvent( media, event );
+	}
+}
 
-		// Restore the texture
-		restoreMovieImage();
+// 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 );
 	}
-	mMediaSource = NULL;
 }
 
-void LLViewerMediaImpl::play(const std::string& media_url,
-							 const std::string& mime_type,
-							 const LLUUID& placeholder_texture_id,
-							 S32 media_width, S32 media_height, U8 media_auto_scale,
-							 U8 media_loop)
+
+// 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::Responder
 {
-	// first stop any previously playing media
-	stop();
+LOG_CLASS(LLMimeDiscoveryResponder);
+public:
+	LLMimeDiscoveryResponder( viewer_media_t media_impl)
+		: mMediaImpl(media_impl),
+		  mInitialized(false)
+	{}
+
+
 
-	// Save this first, as init/load below may fire events
-	mMovieImageID = placeholder_texture_id;
+	virtual void completedHeader(U32 status, const std::string& reason, const LLSD& content)
+	{
+		std::string media_type = content["content-type"].asString();
+		std::string::size_type idx1 = media_type.find_first_of(";");
+		std::string mime_type = media_type.substr(0, idx1);
+		completeAny(status, mime_type);
+	}
 
-	// If the mime_type passed in is different than the cached one, and
-	// Auto-discovery is turned OFF, replace the cached mime_type with the new one.
-	if(mime_type != mMimeType &&
-		! gSavedSettings.getBOOL("AutoMimeDiscovery"))
+	virtual void error( U32 status, const std::string& reason )
 	{
-		mMimeType = mime_type;
+		// completeAny(status, "none/none");
 	}
-	LLURI url(media_url);
-	std::string scheme = url.scheme() != "" ? url.scheme() : "http";
 
-	LLMediaManager* mgr = LLMediaManager::getInstance();
-	mMediaSource = mgr->createSourceFromMimeType(scheme, mMimeType );
-	if ( !mMediaSource )
+	void completeAny(U32 status, const std::string& mime_type)
 	{
-		if (mMimeType != "none/none")
+		if(!mInitialized && ! mime_type.empty())
 		{
-			llwarns << "media source create failed " << media_url
-					<< " type " << mMimeType
-					<< llendl;
+			if (mMediaImpl->initializeMedia(mime_type))
+			{
+				mInitialized = true;
+				mMediaImpl->play();
+			}
 		}
-		return;
 	}
 
-	// Store the URL and Mime Type
-	mMediaURL = media_url;
+	public:
+		viewer_media_t mMediaImpl;
+		bool mInitialized;
+};
+typedef std::vector<LLViewerMediaImpl*> impl_list;
+static impl_list sViewerMediaImplList;
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// LLViewerMedia
 
-	if ((media_width != 0) && (media_height != 0))
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+viewer_media_t LLViewerMedia::newMediaImpl(const std::string& media_url,
+														 const LLUUID& texture_id,
+														 S32 media_width, S32 media_height, U8 media_auto_scale,
+														 U8 media_loop,
+														 std::string mime_type)
+{
+	LLViewerMediaImpl* media_impl = getMediaImplFromTextureID(texture_id);
+	if(media_impl == NULL || texture_id.isNull())
 	{
-		mMediaSource->setRequestedMediaSize(media_width, media_height);
+		// Create the media impl
+		media_impl = new LLViewerMediaImpl(media_url, texture_id, media_width, media_height, media_auto_scale, media_loop, mime_type);
+		sViewerMediaImplList.push_back(media_impl);
 	}
-
-	mMediaSource->setLooping(media_loop);
-	mMediaSource->setAutoScaled(media_auto_scale);
-	mMediaSource->addObserver( this );
-	mMediaSource->navigateTo( media_url );
-	mMediaSource->addCommand(LLMediaBase::COMMAND_START);
+	else
+	{
+		media_impl->stop();
+		media_impl->mTextureId = texture_id;
+		media_impl->mMediaURL = media_url;
+		media_impl->mMediaWidth = media_width;
+		media_impl->mMediaHeight = media_height;
+		media_impl->mMediaAutoScale = media_auto_scale;
+		media_impl->mMediaLoop = media_loop;
+		if(! media_url.empty())
+			media_impl->navigateTo(media_url, mime_type, true);
+	}
+	return media_impl;
 }
 
-void LLViewerMediaImpl::stop()
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+void LLViewerMedia::removeMedia(LLViewerMediaImpl* media)
 {
-	destroyMediaSource();
+	impl_list::iterator iter = sViewerMediaImplList.begin();
+	impl_list::iterator end = sViewerMediaImplList.end();
+	
+	for(; iter != end; iter++)
+	{
+		if(media == *iter)
+		{
+			sViewerMediaImplList.erase(iter);
+			return;
+		}
+	}
 }
 
-void LLViewerMediaImpl::pause()
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+LLViewerMediaImpl* LLViewerMedia::getMediaImplFromTextureID(const LLUUID& texture_id)
 {
-	if(mMediaSource)
+	impl_list::iterator iter = sViewerMediaImplList.begin();
+	impl_list::iterator end = sViewerMediaImplList.end();
+
+	for(; iter != end; iter++)
 	{
-		mMediaSource->addCommand(LLMediaBase::COMMAND_PAUSE);
+		LLViewerMediaImpl* media_impl = *iter;
+		if(media_impl->getMediaTextureID() == texture_id)
+		{
+			return media_impl;
+		}
 	}
+	return NULL;
 }
 
-void LLViewerMediaImpl::start()
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+std::string LLViewerMedia::getCurrentUserAgent()
 {
-	if(mMediaSource)
+	// 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 << LL_VERSION_MAJOR << "." << LL_VERSION_MINOR << "." << LL_VERSION_PATCH << "." << LL_VERSION_BUILD;
+	codec << " (" << channel << "; " << skin_name << " skin)";
+	llinfos << codec.str() << llendl;
+	
+	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++)
 	{
-		mMediaSource->addCommand(LLMediaBase::COMMAND_START);
+		LLViewerMediaImpl* pimpl = *iter;
+		if(pimpl->mMediaSource && pimpl->mMediaSource->pluginSupportsMediaBrowser())
+		{
+			pimpl->mMediaSource->setBrowserUserAgent(user_agent);
+		}
 	}
+
 }
 
-void LLViewerMediaImpl::seek(F32 time)
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+bool LLViewerMedia::handleSkinCurrentChanged(const LLSD& /*newvalue*/)
 {
-	if(mMediaSource)
+	// 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++)
 	{
-		mMediaSource->seek(time);
+		LLViewerMediaImpl* pimpl = *iter;
+		if(pimpl->getMediaTextureID() == texture_id)
+		{
+			return true;
+		}
 	}
+	return false;
 }
 
-void LLViewerMediaImpl::setVolume(F32 volume)
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+void LLViewerMedia::setVolume(F32 volume)
 {
-	if(mMediaSource)
+	impl_list::iterator iter = sViewerMediaImplList.begin();
+	impl_list::iterator end = sViewerMediaImplList.end();
+
+	for(; iter != end; iter++)
 	{
-		mMediaSource->setVolume( volume);
+		LLViewerMediaImpl* pimpl = *iter;
+		pimpl->setVolume(volume);
 	}
 }
 
-LLMediaBase::EStatus LLViewerMediaImpl::getStatus()
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+void LLViewerMedia::updateMedia()
 {
-	if (mMediaSource)
+	impl_list::iterator iter = sViewerMediaImplList.begin();
+	impl_list::iterator end = sViewerMediaImplList.end();
+
+	for(; iter != end; iter++)
 	{
-		return mMediaSource->getStatus();
+		LLViewerMediaImpl* pimpl = *iter;
+		pimpl->update();
 	}
-	else
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// static
+void LLViewerMedia::cleanupClass()
+{
+	// This is no longer necessary, since the list is no longer smart pointers.
+#if 0
+	while(!sViewerMediaImplList.empty())
 	{
-		return LLMediaBase::STATUS_UNKNOWN;
+		sViewerMediaImplList.pop_back();
 	}
+#endif
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// LLViewerMediaImpl
+//////////////////////////////////////////////////////////////////////////////////////////
+LLViewerMediaImpl::LLViewerMediaImpl(const std::string& media_url, 
+										  const LLUUID& texture_id, 
+										  S32 media_width, 
+										  S32 media_height, 
+										  U8 media_auto_scale, 
+										  U8 media_loop,
+										  const std::string& mime_type)
+:	
+	mMediaSource( NULL ),
+	mMovieImageHasMips(false),
+	mTextureId(texture_id),
+	mMediaWidth(media_width),
+	mMediaHeight(media_height),
+	mMediaAutoScale(media_auto_scale),
+	mMediaLoop(media_loop),
+	mMediaURL(media_url),
+	mMimeType(mime_type),
+	mNeedsNewTexture(true),
+	mSuspendUpdates(false),
+	mVisible(true)
+{ 
+	createMediaSource();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
-void LLViewerMediaImpl::restoreMovieImage()
+LLViewerMediaImpl::~LLViewerMediaImpl()
 {
-	// IF the media image hasn't changed, do nothing
-	if (mMovieImageID.isNull())
+	if( gEditMenuHandler == this )
 	{
-		return;
+		gEditMenuHandler = NULL;
 	}
+	
+	destroyMediaSource();
+	LLViewerMedia::removeMedia(this);
+}
 
-	//restore the movie image to the old one
-	LLViewerMediaTexture* media = LLViewerTextureManager::findMediaTexture( mMovieImageID ) ;
-	if (media)
+//////////////////////////////////////////////////////////////////////////////////////////
+bool LLViewerMediaImpl::initializeMedia(const std::string& mime_type)
+{
+	if((mMediaSource == NULL) || (mMimeType != mime_type))
 	{
-		if(media->getOldTexture())//set back to the old texture if it exists
+		if(! initializePlugin(mime_type))
 		{
-			media->switchToTexture(media->getOldTexture()) ;
-			media->setPlaying(FALSE) ;
+			LL_WARNS("Plugin") << "plugin intialization failed for mime type: " << mime_type << LL_ENDL;
+			LLSD args;
+			args["MIME_TYPE"] = mime_type;
+			LLNotifications::instance().add("NoPlugin", args);
+
+			return false;
 		}
-		media->reinit(mMovieImageHasMips);
 	}
-	mMovieImageID.setNull();
-}
 
+	// play();
+	return (mMediaSource != NULL);
+}
 
 //////////////////////////////////////////////////////////////////////////////////////////
-void LLViewerMediaImpl::updateImagesMediaStreams()
+void LLViewerMediaImpl::createMediaSource()
 {
-	LLMediaManager::updateClass();
+	if(! mMediaURL.empty())
+	{
+		navigateTo(mMediaURL, mMimeType, true);
+	}
+	else if(! mMimeType.empty())
+	{
+		initializeMedia(mMimeType);
+	}
+	
 }
 
-void LLViewerMediaImpl::initializePlaceholderImage(LLViewerMediaTexture *placeholder_image, LLMediaBase *media_source)
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::destroyMediaSource()
 {
-	int media_width = media_source->getMediaWidth();
-	int media_height = media_source->getMediaHeight();
-	//int media_rowspan = media_source->getMediaRowSpan();
-
-	// if width & height are invalid, don't bother doing anything
-	if ( media_width < 1 || media_height < 1 )
+	mNeedsNewTexture = true;
+	if(! mMediaSource)
+	{
 		return;
+	}
+	// Restore the texture
+	updateMovieImage(LLUUID::null, false);
+	delete mMediaSource;
+	mMediaSource = NULL;
+}
 
-	llinfos << "initializing media placeholder" << llendl;
-	llinfos << "movie image id " << mMovieImageID << llendl;
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::setMediaType(const std::string& media_type)
+{
+	mMimeType = media_type;
+}
 
-	int texture_width = LLMediaManager::textureWidthFromMediaWidth( media_width );
-	int texture_height = LLMediaManager::textureHeightFromMediaHeight( media_height );
-	int texture_depth = media_source->getMediaDepth();
+//////////////////////////////////////////////////////////////////////////////////////////
+/*static*/
+LLPluginClassMedia* LLViewerMediaImpl::newSourceFromMediaType(std::string media_type, LLPluginClassMediaOwner *owner /* may be NULL */, S32 default_width, S32 default_height)
+{
+	std::string plugin_basename = LLMIMETypes::implType(media_type);
 
-	// 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
+	if(plugin_basename.empty())
+	{
+		LL_WARNS("Media") << "Couldn't find plugin for media type " << media_type << LL_ENDL;
+	}
+	else
+	{
+		std::string plugins_path = gDirUtilp->getLLPluginDir();
+		plugins_path += gDirUtilp->getDirDelimiter();
+		
+		std::string launcher_name = gDirUtilp->getLLPluginLauncher();
+		std::string plugin_name = gDirUtilp->getLLPluginFilename(plugin_basename);
+
+		// See if the plugin executable exists
+		llstat s;
+		if(LLFile::stat(launcher_name, &s))
+		{
+			LL_WARNS("Media") << "Couldn't find launcher at " << launcher_name << LL_ENDL;
+		}
+		else if(LLFile::stat(plugin_name, &s))
+		{
+			LL_WARNS("Media") << "Couldn't find plugin at " << plugin_name << LL_ENDL;
+		}
+		else
+		{
+			LLPluginClassMedia* media_source = new LLPluginClassMedia(owner);
+			media_source->setSize(default_width, default_height);
+			if (media_source->init(launcher_name, plugin_name))
+			{
+				return media_source;
+			}
+			else
+			{
+				LL_WARNS("Media") << "Failed to init plugin.  Destroying." << LL_ENDL;
+				delete media_source;
+			}
+		}
+	}
+	
+	return NULL;
+}							
 
-	// 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);
-	raw->clear(0x0f, 0x0f, 0x0f, 0xff);
-	int discard_level = 0;
+//////////////////////////////////////////////////////////////////////////////////////////
+bool LLViewerMediaImpl::initializePlugin(const std::string& media_type)
+{
+	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;
 
-	// ask media source for correct GL image format constants
-	placeholder_image->setExplicitFormat(media_source->getTextureFormatInternal(),
-										 media_source->getTextureFormatPrimary(),
-										 media_source->getTextureFormatType());
+	LLPluginClassMedia* media_source = newSourceFromMediaType(media_type, this, mMediaWidth, mMediaHeight);
+	
+	if (media_source)
+	{
+		media_source->setDisableTimeout(gSavedSettings.getBOOL("DebugPluginDisableTimeout"));
+		media_source->setLoop(mMediaLoop);
+		media_source->setAutoScale(mMediaAutoScale);
+		media_source->setBrowserUserAgent(LLViewerMedia::getCurrentUserAgent());
+		
+		mMediaSource = media_source;
+		return true;
+	}
 
-	placeholder_image->createGLTexture(discard_level, raw);
+	return false;
+}
 
-	// placeholder_image->setExplicitFormat()
-	placeholder_image->setUseMipMaps(FALSE);
+void LLViewerMediaImpl::setSize(int width, int height)
+{
+	mMediaWidth = width;
+	mMediaHeight = height;
+	if(mMediaSource)
+	{
+		mMediaSource->setSize(width, height);
+	}
 }
 
-// virtual
-void LLViewerMediaImpl::onMediaContentsChange(const EventType& event_in)
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::play()
 {
-	LLMediaBase* media_source = event_in.getSubject();
-	LLViewerMediaTexture* placeholder_image = LLViewerTextureManager::getMediaTexture( mMovieImageID ) ;
-	if (placeholder_image && placeholder_image->hasValidGLTexture())
+	// first stop any previously playing media
+	// stop();
+
+	// mMediaSource->addObserver( this );
+	if(mMediaSource == NULL)
 	{
-		if (placeholder_image->getUseMipMaps())
+	 	if(!initializePlugin(mMimeType))
 		{
-			// bad image!  NO MIPMAPS!
-			initializePlaceholderImage(placeholder_image, media_source);
+			// Plugin failed initialization... should assert or something
+			return;
 		}
+	}
+	
+	// updateMovieImage(mTextureId, true);
 
-		U8* data = media_source->getMediaData();
-		S32 x_pos = 0;
-		S32 y_pos = 0;
-		S32 width = media_source->getMediaWidth();
-		S32 height = media_source->getMediaHeight();
-		S32 data_width = media_source->getMediaDataWidth();
-		S32 data_height = media_source->getMediaDataHeight();
-		placeholder_image->setSubImage(data, data_width, data_height,
-			x_pos, y_pos, width, height);
+	mMediaSource->loadURI( mMediaURL );
+	if(/*mMediaSource->pluginSupportsMediaTime()*/ true)
+	{
+		start();
 	}
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::stop()
+{
+	if(mMediaSource)
+	{
+		mMediaSource->stop();
+		// destroyMediaSource();
+	}
+}
 
-// virtual
-void LLViewerMediaImpl::onMediaSizeChange(const EventType& event_in)
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::pause()
 {
-	LLMediaBase* media_source = event_in.getSubject();
-	LLViewerMediaTexture* placeholder_image = LLViewerTextureManager::getMediaTexture( mMovieImageID ) ;
-	if (placeholder_image)
+	if(mMediaSource)
 	{
-		initializePlaceholderImage(placeholder_image, media_source);
+		mMediaSource->pause();
 	}
-	else
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::start()
+{
+	if(mMediaSource)
 	{
-		llinfos << "no placeholder image" << llendl;
+		mMediaSource->start();
 	}
 }
 
-LLUUID LLViewerMediaImpl::getMediaTextureID()
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::seek(F32 time)
 {
-	return mMovieImageID;
+	if(mMediaSource)
+	{
+		mMediaSource->seek(time);
+	}
 }
 
-// static
-void LLViewerMediaImpl::updateBrowserUserAgent()
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::setVolume(F32 volume)
 {
-	// Don't use user-visible string to avoid 
-	// punctuation and strange characters.
-	std::string skin_name = gSavedSettings.getString("SkinCurrent");
+	if(mMediaSource)
+	{
+		mMediaSource->setVolume(volume);
+	}
+}
 
-	// Just in case we need to check browser differences in A/B test
-	// builds.
-	std::string channel = gSavedSettings.getString("VersionChannelName");
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::focus(bool focus)
+{
+	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);
+		}
+	}
+}
 
-	// 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 << LL_VERSION_MAJOR << "." << LL_VERSION_MINOR << "." << LL_VERSION_PATCH << "." << LL_VERSION_BUILD;
-	codec << " (" << channel << "; " << skin_name << " skin)";
-	llinfos << codec.str() << llendl;
-	LLMediaManager::setBrowserUserAgent( codec.str() );
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::mouseDown(S32 x, S32 y)
+{
+	scaleMouse(&x, &y);
+	mLastMouseX = x;
+	mLastMouseY = y;
+	if (mMediaSource)
+	{
+		mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOWN, x, y, 0);
+	}
 }
 
-// static
-bool LLViewerMediaImpl::handleSkinCurrentChanged(const LLSD& /*newvalue*/)
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::mouseUp(S32 x, S32 y)
 {
-	// gSavedSettings is already updated when this function is called.
-	updateBrowserUserAgent();
-	return true;
+	scaleMouse(&x, &y);
+	mLastMouseX = x;
+	mLastMouseY = y;
+	if (mMediaSource)
+	{
+		mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, x, y, 0);
+	}
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// Wrapper class
+void LLViewerMediaImpl::mouseMove(S32 x, S32 y)
+{
+	scaleMouse(&x, &y);
+	mLastMouseX = x;
+	mLastMouseY = y;
+	if (mMediaSource)
+	{
+		mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_MOVE, x, y, 0);
+	}
+}
+
 //////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::mouseLeftDoubleClick(S32 x, S32 y)
+{
+	scaleMouse(&x, &y);
+	mLastMouseX = x;
+	mLastMouseY = y;
+	if (mMediaSource)
+	{
+		mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_DOUBLE_CLICK, x, y, 0);
+	}
+}
 
-S32 LLViewerMedia::mMusicState = LLViewerMedia::STOPPED;
 //////////////////////////////////////////////////////////////////////////////////////////
-// The viewer takes a long time to load the start screen.  Part of the problem
-// is media initialization -- in particular, QuickTime loads many DLLs and
-// hits the disk heavily.  So we initialize only the browser component before
-// the login screen, then do the rest later when we have a progress bar. JC
-// static
-void LLViewerMedia::initBrowser()
+void LLViewerMediaImpl::onMouseCaptureLost()
 {
-	LLMediaManagerData* init_data = new LLMediaManagerData;
-	buildMediaManagerData( init_data );
-	LLMediaManager::initBrowser( init_data );
-	delete init_data;
+	if (mMediaSource)
+	{
+		mMediaSource->mouseEvent(LLPluginClassMedia::MOUSE_EVENT_UP, 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 );
+	}
 
-	// We use a custom user agent with viewer version and skin name.
-	LLViewerMediaImpl::updateBrowserUserAgent();
+	return TRUE; 
+}
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::navigateHome()
+{
+	if(mMediaSource)
+	{
+		mMediaSource->loadURI( mHomeURL );
+	}
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// static
-void LLViewerMedia::initClass()
+void LLViewerMediaImpl::navigateTo(const std::string& url, const std::string& mime_type,  bool rediscover_type)
 {
-	// *TODO: This looks like a memory leak to me. JC
-	LLMediaManagerData* init_data = new LLMediaManagerData;
-	buildMediaManagerData( init_data );
-	LLMediaManager::initClass( init_data );
-	delete init_data;
+	if(rediscover_type)
+	{
+
+		LLURI uri(url);
+		std::string scheme = uri.scheme();
+
+		if(scheme.empty() || "http" == scheme || "https" == scheme)
+		{
+			LLHTTPClient::getHeaderOnly( url, new LLMimeDiscoveryResponder(this));
+		}
+		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"))
+			{
+				mMediaSource->loadURI( url );
+			}
+		}
+		else
+		{
+			// This catches 'rtsp://' urls
+			if(initializeMedia(scheme))
+			{
+				mMediaSource->loadURI( url );
+			}
+		}
+	}
+	else if (mMediaSource)
+	{
+		mMediaSource->loadURI( url );
+	}
+	else if(initializeMedia(mime_type) && mMediaSource)
+	{
+		mMediaSource->loadURI( url );
+	}
+	else
+	{
+		LL_WARNS("Media") << "Couldn't navigate to: " << url << " as there is no media type for: " << mime_type << LL_ENDL;
+		return;
+	}
+	mMediaURL = url;
+
+}
 
-	LLMediaManager* mm = LLMediaManager::getInstance();
-	LLMIMETypes::mime_info_map_t::const_iterator it;
-	for (it = LLMIMETypes::sMap.begin(); it != LLMIMETypes::sMap.end(); ++it)
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::navigateStop()
+{
+	if(mMediaSource)
 	{
-		const std::string& mime_type = it->first;
-		const LLMIMETypes::LLMIMEInfo& info = it->second;
-		mm->addMimeTypeImplNameMap( mime_type, info.mImpl );
+		mMediaSource->browse_stop();
 	}
+
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// static
-void LLViewerMedia::buildMediaManagerData( LLMediaManagerData* init_data )
-{
-//	std::string executable_dir = std::string( arg0 ).substr( 0, std::string( arg0 ).find_last_of("\\/") );
-//	std::string component_dir = std::string( executable_dir ).substr( 0, std::string( executable_dir ).find_last_of("\\/") );
-//	component_dir = std::string( component_dir ).substr( 0, std::string( component_dir ).find_last_of("\\/") );
-//	component_dir = std::string( component_dir ).substr( 0, std::string( component_dir ).find_last_of("\\/") );
-//	component_dir += "\\newview\\app_settings\\mozilla";
-
-
-#if LL_DARWIN
-	// For Mac OS, we store both the shared libraries and the runtime files (chrome/, plugins/, etc) in
-	// Second Life.app/Contents/MacOS/.  This matches the way Firefox is distributed on the Mac.
-	std::string component_dir(gDirUtilp->getExecutableDir());
-#elif LL_WINDOWS
-	std::string component_dir( gDirUtilp->getExpandedFilename( LL_PATH_APP_SETTINGS, "" ) );
-	component_dir += gDirUtilp->getDirDelimiter();
-  #ifdef LL_DEBUG
-	component_dir += "mozilla_debug";
+bool LLViewerMediaImpl::handleKeyHere(KEY key, MASK mask)
+{
+	bool result = false;
 	// *NOTE:Mani - if this doesn't exist llmozlib goes crashy in the debug build.
 	// LLMozlib::init wants to write some files to <exe_dir>/components
 	std::string debug_init_component_dir( gDirUtilp->getExecutableDir() );
 	debug_init_component_dir += "/components";
 	LLAPRFile::makeDir(debug_init_component_dir.c_str()); 
-  #else // LL_DEBUG
-	component_dir += "mozilla";
-  #endif // LL_DEBUG
-#elif LL_LINUX
-	std::string component_dir( gDirUtilp->getExpandedFilename( LL_PATH_APP_SETTINGS, "" ) );
-	component_dir += gDirUtilp->getDirDelimiter();
-	component_dir += "mozilla-runtime-linux-i686";
-#elif LL_SOLARIS
-	std::string component_dir( gDirUtilp->getExpandedFilename( LL_PATH_APP_SETTINGS, "" ) );
-	component_dir += gDirUtilp->getDirDelimiter();
-	#ifdef  __sparc
-		component_dir += "mozilla-solaris-sparc";
-	#else
-		component_dir += "mozilla-solaris-i686";
-	#endif
-#else
-	std::string component_dir( gDirUtilp->getExpandedFilename( LL_PATH_APP_SETTINGS, "" ) );
-	component_dir += gDirUtilp->getDirDelimiter();
-	component_dir += "mozilla";
-#endif
-
-	std::string application_dir = gDirUtilp->getExecutableDir();
-
-	init_data->setBrowserApplicationDir( application_dir );
-	std::string profile_dir = gDirUtilp->getExpandedFilename( LL_PATH_MOZILLA_PROFILE, "" );
-	init_data->setBrowserProfileDir( profile_dir );
-	init_data->setBrowserComponentDir( component_dir );
-	std::string profile_name("Second Life");
-	init_data->setBrowserProfileName( profile_name );
-	init_data->setBrowserParentWindow( gViewerWindow->getMediaWindow() );
-
-	// Users can change skins while client is running, so make sure
-	// we pick up on changes.
-	gSavedSettings.getControl("SkinCurrent")->getSignal()->connect( 
-		boost::bind( LLViewerMediaImpl::handleSkinCurrentChanged, _2 ) );
-
+	
+	if (mMediaSource)
+	{
+		result = mMediaSource->keyEvent(LLPluginClassMedia::KEY_EVENT_DOWN ,key, mask);
+	}
+	
+	return result;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// static
-void LLViewerMedia::cleanupClass()
+bool LLViewerMediaImpl::handleUnicodeCharHere(llwchar uni_char)
 {
-	stop() ;
-	LLMediaManager::cleanupClass();
+	bool result = false;
+	
+	if (mMediaSource)
+	{
+		mMediaSource->textInput(wstring_to_utf8str(LLWString(1, uni_char)));
+	}
+	
+	return result;
 }
 
-// static
-void LLViewerMedia::play(const std::string& media_url,
-						 const std::string& mime_type,
-						 const LLUUID& placeholder_texture_id,
-						 S32 media_width, S32 media_height, U8 media_auto_scale,
-						 U8 media_loop)
+//////////////////////////////////////////////////////////////////////////////////////////
+bool LLViewerMediaImpl::canNavigateForward()
 {
-	sViewerMediaImpl.play(media_url, mime_type, placeholder_texture_id,
-						  media_width, media_height, media_auto_scale, media_loop);
+	BOOL result = FALSE;
+	if (mMediaSource)
+	{
+		result = mMediaSource->getHistoryForwardAvailable();
+	}
+	return result;
 }
 
-// static
-void LLViewerMedia::stop()
+//////////////////////////////////////////////////////////////////////////////////////////
+bool LLViewerMediaImpl::canNavigateBack()
 {
-	sViewerMediaImpl.stop();
+	BOOL result = FALSE;
+	if (mMediaSource)
+	{
+		result = mMediaSource->getHistoryBackAvailable();
+	}
+	return result;
 }
 
-// static
-void LLViewerMedia::pause()
-{
-	sViewerMediaImpl.pause();
-}
 
-// static
-void LLViewerMedia::start()
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::updateMovieImage(const LLUUID& uuid, BOOL active)
 {
-	sViewerMediaImpl.start();
+	// IF the media image hasn't changed, do nothing
+	if (mTextureId == uuid)
+	{
+		return;
+	}
+	// If we have changed media uuid, restore the old one
+	if (!mTextureId.isNull())
+	{
+		LLViewerMediaTexture* old_image = LLViewerTextureManager::findMediaTexture( mTextureId );
+		if (old_image)
+		{
+			old_image->setPlaying(FALSE);
+			LLViewerTexture* original_texture = old_image->getOldTexture();
+			if(original_texture)
+			{
+				old_image->switchToTexture(original_texture);
+			}
+		}
+	}
+	// If the movie is playing, set the new media image
+	if (active && !uuid.isNull())
+	{
+		LLViewerMediaTexture* viewerImage = LLViewerTextureManager::findMediaTexture( uuid );
+		if( viewerImage )
+		{
+			mTextureId = uuid;
+			
+			// Can't use mipmaps for movies because they don't update the full image
+			mMovieImageHasMips = viewerImage->getUseMipMaps();
+			viewerImage->reinit(FALSE);
+			// FIXME
+//			viewerImage->mIsMediaTexture = TRUE;
+		}
+	}
 }
 
-// static
-void LLViewerMedia::seek(F32 time)
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::update()
 {
-	sViewerMediaImpl.seek(time);
+	if(mMediaSource == NULL)
+	{
+		return;
+	}
+	
+	mMediaSource->idle();
+	
+	if(mMediaSource->isPluginExited())
+	{
+		destroyMediaSource();
+		return;
+	}
+
+	if(!mMediaSource->textureValid())
+	{
+		return;
+	}
+	
+	if(mSuspendUpdates || !mVisible)
+	{
+		return;
+	}
+	
+	LLViewerMediaTexture* placeholder_image = updatePlaceholderImage();
+		
+	if(placeholder_image)
+	{
+		LLRect dirty_rect;
+		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 = 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() );
+				
+				placeholder_image->setSubImage(
+						data, 
+						mMediaSource->getBitsWidth(), 
+						mMediaSource->getBitsHeight(),
+						x_pos, 
+						y_pos, 
+						width, 
+						height);
+
+			}
+			
+			mMediaSource->resetDirty();
+		}
+	}
 }
 
-// static
-void LLViewerMedia::setVolume(F32 volume)
+
+//////////////////////////////////////////////////////////////////////////////////////////
+void LLViewerMediaImpl::updateImagesMediaStreams()
 {
-	sViewerMediaImpl.setVolume(volume);
 }
 
-// static
-LLMediaBase::EStatus LLViewerMedia::getStatus()
+
+//////////////////////////////////////////////////////////////////////////////////////////
+LLViewerMediaTexture* LLViewerMediaImpl::updatePlaceholderImage()
 {
-	return sViewerMediaImpl.getStatus();
+	if(mTextureId.isNull())
+	{
+		// The code that created this instance will read from the plugin's bits.
+		return NULL;
+	}
+	
+	LLViewerMediaTexture* placeholder_image = LLViewerTextureManager::getMediaTexture( mTextureId );
+	
+	if (mNeedsNewTexture 
+		|| placeholder_image->getUseMipMaps()
+//		|| ! placeholder_image->getType() == LLViewerTexture::MEDIA_TEXTURE
+		|| placeholder_image->getWidth() != mMediaSource->getTextureWidth()
+		|| placeholder_image->getHeight() != mMediaSource->getTextureHeight())
+	{
+		llinfos << "initializing media placeholder" << llendl;
+		llinfos << "movie image id " << mTextureId << llendl;
+
+		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);
+		raw->clear(0x0f, 0x0f, 0x0f, 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);
+
+		// placeholder_image->setExplicitFormat()
+		placeholder_image->setUseMipMaps(FALSE);
+
+		// MEDIAOPT: set this dynamically on play/stop
+		// FIXME
+//		placeholder_image->mIsMediaTexture = true;
+		mNeedsNewTexture = false;
+	}
+	
+	return placeholder_image;
 }
 
+
 //////////////////////////////////////////////////////////////////////////////////////////
-// static
-LLUUID LLViewerMedia::getMediaTextureID()
+LLUUID LLViewerMediaImpl::getMediaTextureID()
 {
-	return sViewerMediaImpl.getMediaTextureID();
+	return mTextureId;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// static
-bool LLViewerMedia::getMediaSize(S32 *media_width, S32 *media_height)
+void LLViewerMediaImpl::setVisible(bool visible)
 {
-	// make sure we're valid
-
-	if ( sViewerMediaImpl.mMediaSource != NULL )
+	mVisible = visible;
+	
+	if(mVisible)
 	{
-		*media_width = sViewerMediaImpl.mMediaSource->getMediaWidth();
-		*media_height = sViewerMediaImpl.mMediaSource->getMediaHeight();
-		return true;
+		if(mMediaSource && mMediaSource->isPluginExited())
+		{
+			destroyMediaSource();
+		}
+		
+		if(!mMediaSource)
+		{
+			createMediaSource();
+		}
+	}
+	
+	if(mMediaSource)
+	{
+		mMediaSource->setPriority(mVisible?LLPluginClassMedia::PRIORITY_NORMAL:LLPluginClassMedia::PRIORITY_HIDDEN);
 	}
-	return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// static
-bool LLViewerMedia::getTextureSize(S32 *texture_width, S32 *texture_height)
+void LLViewerMediaImpl::mouseCapture()
 {
-	if ( sViewerMediaImpl.mMediaSource != NULL )
-	{
-		S32 media_width = sViewerMediaImpl.mMediaSource->getMediaWidth();
-		S32 media_height = sViewerMediaImpl.mMediaSource->getMediaHeight();
-		*texture_width = LLMediaManager::textureWidthFromMediaWidth( media_width );
-		*texture_height = LLMediaManager::textureHeightFromMediaHeight( media_height );
-		return true;
-	}
-	return false;
+	gFocusMgr.setMouseCapture(this);
 }
 
-
 //////////////////////////////////////////////////////////////////////////////////////////
-// static
-void LLViewerMedia::updateImagesMediaStreams()
+void LLViewerMediaImpl::scaleMouse(S32 *mouse_x, S32 *mouse_y)
 {
-	sViewerMediaImpl.updateImagesMediaStreams();
+#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
 }
+
 //////////////////////////////////////////////////////////////////////////////////////////
-// static
-bool LLViewerMedia::isMediaPlaying()
+bool LLViewerMediaImpl::isMediaPlaying()
 {
-	LLMediaBase::EStatus status = sViewerMediaImpl.getStatus();
-	return (status == LLMediaBase::STATUS_STARTED );
+	bool result = false;
+	
+	if(mMediaSource)
+	{
+		EMediaStatus status = mMediaSource->getStatus();
+		if(status == MEDIA_PLAYING || status == MEDIA_LOADING)
+			result = true;
+	}
+	
+	return result;
 }
 //////////////////////////////////////////////////////////////////////////////////////////
-// static
-bool LLViewerMedia::isMediaPaused()
+bool LLViewerMediaImpl::isMediaPaused()
 {
-	LLMediaBase::EStatus status = sViewerMediaImpl.getStatus();
-	return (status == LLMediaBase::STATUS_PAUSED);
+	bool result = false;
+
+	if(mMediaSource)
+	{
+		if(mMediaSource->getStatus() == MEDIA_PAUSED)
+			result = true;
+	}
+	
+	return result;
 }
+
 //////////////////////////////////////////////////////////////////////////////////////////
-// static
-bool LLViewerMedia::hasMedia()
+//
+bool LLViewerMediaImpl::hasMedia()
 {
-	return sViewerMediaImpl.mMediaSource != NULL;
+	return mMediaSource != NULL;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
-//static
-bool LLViewerMedia::isActiveMediaTexture(const LLUUID& id)
+void LLViewerMediaImpl::handleMediaEvent(LLPluginClassMedia* self, LLPluginClassMediaOwner::EMediaEvent event)
 {
-	return (id.notNull()
-		&& id == getMediaTextureID()
-		&& isMediaPlaying());
+	switch(event)
+	{
+		case MEDIA_EVENT_PLUGIN_FAILED:
+		{
+			LLSD args;
+			args["PLUGIN"] = LLMIMETypes::implType(mMimeType);
+			LLNotifications::instance().add("MediaPluginFailed", args);
+		}
+		break;
+		default:
+		break;
+	}
+	// Just chain the event to observers.
+	emitEvent(self, event);
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////
-//static
-bool LLViewerMedia::isMusicPlaying()
+////////////////////////////////////////////////////////////////////////////////
+// virtual
+void
+LLViewerMediaImpl::cut()
 {
-	return mMusicState == PLAYING; 
+	if (mMediaSource)
+		mMediaSource->cut();
 }
 
-//////////////////////////////////////////////////////////////////////////////////////////
-// static
-std::string LLViewerMedia::getMediaURL()
+////////////////////////////////////////////////////////////////////////////////
+// virtual
+BOOL
+LLViewerMediaImpl::canCut() const
+{
+	if (mMediaSource)
+		return mMediaSource->canCut();
+	else
+		return FALSE;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// virtual
+void
+LLViewerMediaImpl::copy()
 {
-	return sViewerMediaImpl.mMediaURL;
+	if (mMediaSource)
+		mMediaSource->copy();
 }
-//////////////////////////////////////////////////////////////////////////////////////////
-// static
-std::string LLViewerMedia::getMimeType()
+
+////////////////////////////////////////////////////////////////////////////////
+// virtual
+BOOL
+LLViewerMediaImpl::canCopy() const
 {
-	return sViewerMediaImpl.mMimeType;
+	if (mMediaSource)
+		return mMediaSource->canCopy();
+	else
+		return FALSE;
 }
-//////////////////////////////////////////////////////////////////////////////////////////
-// static
-void LLViewerMedia::setMimeType(std::string mime_type)
+
+////////////////////////////////////////////////////////////////////////////////
+// virtual
+void
+LLViewerMediaImpl::paste()
 {
-	sViewerMediaImpl.mMimeType = mime_type;
+	if (mMediaSource)
+		mMediaSource->paste();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// virtual
+BOOL
+LLViewerMediaImpl::canPaste() const
+{
+	if (mMediaSource)
+		return mMediaSource->canPaste();
+	else
+		return FALSE;
 }
 
+
 //////////////////////////////////////////////////////////////////////////////////////////
 //static
 void LLViewerMedia::toggleMusicPlay(void*)
 {
+// FIXME: This probably doesn't belong here
+#if 0
 	if (mMusicState != PLAYING)
 	{
 		mMusicState = PLAYING; // desired state
@@ -661,12 +1170,15 @@ void LLViewerMedia::toggleMusicPlay(void*)
 			gAudiop->stopInternetStream();
 		}
 	}
+#endif
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //static
 void LLViewerMedia::toggleMediaPlay(void*)
 {
+// FIXME: This probably doesn't belong here
+#if 0
 	if (LLViewerMedia::isMediaPaused())
 	{
 		LLViewerParcelMedia::start();
@@ -683,11 +1195,24 @@ void LLViewerMedia::toggleMediaPlay(void*)
 			LLViewerParcelMedia::play(parcel);
 		}
 	}
+#endif
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 //static
 void LLViewerMedia::mediaStop(void*)
 {
+// FIXME: This probably doesn't belong here
+#if 0
 	LLViewerParcelMedia::stop();
+#endif
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//static 
+bool LLViewerMedia::isMusicPlaying()
+{	
+// FIXME: This probably doesn't belong here
+// FIXME: make this work
+	return false;	
 }