MAINT-6578 Broken texture batching - fixed along with misc LibVLC plugin additions (status, titles, looping)

4 files changed, 407 insertions, 236 deletions

diff --git a/indra/media_plugins/base/media_plugin_base.cpp b/indra/media_plugins/base/media_plugin_base.cpp
index 37c498664a..a813d5f465 100644
--- a/indra/media_plugins/base/media_plugin_base.cpp
+++ b/indra/media_plugins/base/media_plugin_base.cpp
@@ -73,6 +73,7 @@ std::string MediaPluginBase::statusString()
 		case STATUS_PLAYING:	result = "playing";		break;
 		case STATUS_PAUSED:		result = "paused";		break;
 		case STATUS_DONE:		result = "done";		break;
+		case STATUS_BUFFERING:	result = "buffering";	break;
 		default:
 			// keep the empty string
 		break;
diff --git a/indra/media_plugins/base/media_plugin_base.h b/indra/media_plugins/base/media_plugin_base.h
index 38b8226bb3..99bc49fc70 100644
--- a/indra/media_plugins/base/media_plugin_base.h
+++ b/indra/media_plugins/base/media_plugin_base.h
@@ -56,7 +56,8 @@ protected:
 		STATUS_ERROR,
 		STATUS_PLAYING,
 		STATUS_PAUSED,
-		STATUS_DONE
+		STATUS_DONE,
+		STATUS_BUFFERING
 	} EStatus;
 
    /** Plugin shared memory. */
diff --git a/indra/media_plugins/cef/media_plugin_cef.cpp b/indra/media_plugins/cef/media_plugin_cef.cpp
index be16ff7946..28a8a5886a 100644
--- a/indra/media_plugins/cef/media_plugin_cef.cpp
+++ b/indra/media_plugins/cef/media_plugin_cef.cpp
@@ -189,7 +189,7 @@ void MediaPluginCEF::onPageChangedCallback(unsigned char* pixels, int x, int y,
 				mPopupH = height;
 				mPopupW = width;
 				mPopupX = x;
-				mPopupY = y;
+				mPopupY = mHeight - y - height;
 			}
 		}
 		else
@@ -526,7 +526,7 @@ void MediaPluginCEF::receiveMessage(const char* message_string)
 				message.setValueU32("internalformat", GL_RGB);
 				message.setValueU32("format", GL_BGRA);
 				message.setValueU32("type", GL_UNSIGNED_BYTE);
-				message.setValueBoolean("coords_opengl", false);
+				message.setValueBoolean("coords_opengl", true);
 				sendMessage(message);
 			}
 			else if (message_name == "set_user_data_path")
diff --git a/indra/media_plugins/libvlc/media_plugin_libvlc.cpp b/indra/media_plugins/libvlc/media_plugin_libvlc.cpp
index 8ef4ee2a27..f2e8252d3a 100644
--- a/indra/media_plugins/libvlc/media_plugin_libvlc.cpp
+++ b/indra/media_plugins/libvlc/media_plugin_libvlc.cpp
@@ -1,30 +1,30 @@
 /**
- * @file media_plugin_libvlc.cpp
- * @brief LibVLC plugin for LLMedia API plugin system
- *
- * @cond
- * $LicenseInfo:firstyear=2008&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- * @endcond
- */
+* @file media_plugin_libvlc.cpp
+* @brief LibVLC plugin for LLMedia API plugin system
+*
+* @cond
+* $LicenseInfo:firstyear=2008&license=viewerlgpl$
+* Second Life Viewer Source Code
+* Copyright (C) 2010, Linden Research, Inc.
+*
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation;
+* version 2.1 of the License only.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*
+* Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+* $/LicenseInfo$
+* @endcond
+*/
 
 #include "linden_common.h"
 
@@ -40,61 +40,78 @@
 ////////////////////////////////////////////////////////////////////////////////
 //
 class MediaPluginLibVLC :
-        public MediaPluginBase
+	public MediaPluginBase
 {
-    public:
-        MediaPluginLibVLC( LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data );
-        ~MediaPluginLibVLC();
+public:
+	MediaPluginLibVLC(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data);
+	~MediaPluginLibVLC();
 
-        /*virtual*/ void receiveMessage( const char* message_string );
+	/*virtual*/ void receiveMessage(const char* message_string);
 
-    private:
-        bool init();
+private:
+	bool init();
 
-		void initVLC();
-		void playMedia();
-		void resetVLC();
-		void setVolume(const F64 volume);
+	void initVLC();
+	void playMedia();
+	void resetVLC();
+	void setVolume(const F64 volume);
+	void updateTitle(const char* title);
 
-		static void* lock(void* data, void** p_pixels);
-		static void unlock(void* data, void* id, void* const* raw_pixels);
-		static void display(void* data, void* id);
+	static void* lock(void* data, void** p_pixels);
+	static void unlock(void* data, void* id, void* const* raw_pixels);
+	static void display(void* data, void* id);
 
-		libvlc_instance_t* gLibVLC;
-		libvlc_media_t* gLibVLCMedia;
-		libvlc_media_player_t* gLibVLCMediaPlayer;
+	/*virtual*/ void setDirty(int left, int top, int right, int bottom) override;
 
-		struct gVLCContext
-		{
-			unsigned char* texture_pixels;
-			libvlc_media_player_t* mp;
-			MediaPluginLibVLC* parent;
-		};
-		struct gVLCContext gVLCCallbackContext;
+	static void eventCallbacks(const libvlc_event_t* event, void* ptr);
+
+	libvlc_instance_t* mLibVLC;
+	libvlc_media_t* mLibVLCMedia;
+	libvlc_media_player_t* mLibVLCMediaPlayer;
+
+	struct mLibVLCContext
+	{
+		unsigned char* texture_pixels;
+		libvlc_media_player_t* mp;
+		MediaPluginLibVLC* parent;
+	};
+	struct mLibVLCContext mLibVLCCallbackContext;
+
+	std::string mURL;
+	F64 mCurVolume;
+
+	bool mIsLooping;
 
-		std::string mURL;
-		F64 mCurVolume;
+	float mCurTime;
+	float mDuration;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-MediaPluginLibVLC::MediaPluginLibVLC( LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data ) :
-    MediaPluginBase( host_send_func, host_user_data )
+MediaPluginLibVLC::MediaPluginLibVLC(LLPluginInstance::sendMessageFunction host_send_func, void *host_user_data) :
+MediaPluginBase(host_send_func, host_user_data)
 {
 	mTextureWidth = 0;
 	mTextureHeight = 0;
-    mWidth = 0;
-    mHeight = 0;
-    mDepth = 4;
-    mPixels = 0;
+	mWidth = 0;
+	mHeight = 0;
+	mDepth = 4;
+	mPixels = 0;
 
-	gLibVLC = 0;
-	gLibVLCMedia = 0;
-	gLibVLCMediaPlayer = 0;
+	mLibVLC = 0;
+	mLibVLCMedia = 0;
+	mLibVLCMediaPlayer = 0;
 
 	mCurVolume = 0.0;
 
+	mIsLooping = false;
+
+	mCurTime = 0.0;
+	mDuration = 0.0;
+
 	mURL = std::string();
+
+	setStatus(STATUS_NONE);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -107,7 +124,7 @@ MediaPluginLibVLC::~MediaPluginLibVLC()
 //
 void* MediaPluginLibVLC::lock(void* data, void** p_pixels)
 {
-	struct gVLCContext* context = (gVLCContext*)data;
+	struct mLibVLCContext* context = (mLibVLCContext*)data;
 
 	*p_pixels = context->texture_pixels;
 
@@ -118,15 +135,16 @@ void* MediaPluginLibVLC::lock(void* data, void** p_pixels)
 //
 void MediaPluginLibVLC::unlock(void* data, void* id, void* const* raw_pixels)
 {
-	// nothing to do here for the moment.
-	// we can modify the raw_pixels here if we want to.
+	// nothing to do here for the moment
+	// we *could* modify pixels here to, for example, Y flip, but this is done with
+	// a VLC video filter transform. 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 void MediaPluginLibVLC::display(void* data, void* id)
 {
-	struct gVLCContext* context = (gVLCContext*)data;
+	struct mLibVLCContext* context = (mLibVLCContext*)data;
 
 	context->parent->setDirty(0, 0, context->parent->mWidth, context->parent->mHeight);
 }
@@ -138,12 +156,13 @@ void MediaPluginLibVLC::initVLC()
 	char const* vlc_argv[] =
 	{
 		"--no-xlib",
+		"--video-filter=transform{type=vflip}",  // MAINT-6578 Y flip textures in plugin vs client
 	};
 
 	int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
-	gLibVLC = libvlc_new(vlc_argc, vlc_argv);
+	mLibVLC = libvlc_new(vlc_argc, vlc_argv);
 
-	if (!gLibVLC)
+	if (!mLibVLC)
 	{
 		// for the moment, if this fails, the plugin will fail and 
 		// the media sub-system will tell the viewer something went wrong.
@@ -154,9 +173,91 @@ void MediaPluginLibVLC::initVLC()
 //
 void MediaPluginLibVLC::resetVLC()
 {
-	libvlc_media_player_stop(gLibVLCMediaPlayer);
-	libvlc_media_player_release(gLibVLCMediaPlayer);
-	libvlc_release(gLibVLC);
+	libvlc_media_player_stop(mLibVLCMediaPlayer);
+	libvlc_media_player_release(mLibVLCMediaPlayer);
+	libvlc_release(mLibVLC);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// *virtual*
+void MediaPluginLibVLC::setDirty(int left, int top, int right, int bottom)
+{
+	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "updated");
+
+	message.setValueS32("left", left);
+	message.setValueS32("top", top);
+	message.setValueS32("right", right);
+	message.setValueS32("bottom", bottom);
+
+	message.setValueReal("current_time", mCurTime);
+	message.setValueReal("duration", mDuration);
+	message.setValueReal("current_rate", 1.0f);
+
+	sendMessage(message);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+void MediaPluginLibVLC::eventCallbacks(const libvlc_event_t* event, void* ptr)
+{
+	MediaPluginLibVLC* parent = (MediaPluginLibVLC*)ptr;
+	if (parent == 0)
+	{
+		return;
+	}
+
+	switch (event->type)
+	{
+	case libvlc_MediaPlayerOpening:
+		parent->setStatus(STATUS_LOADING);
+		break;
+
+	case libvlc_MediaPlayerBuffering:
+		parent->setStatus(STATUS_BUFFERING);
+		break;
+
+	case libvlc_MediaPlayerPlaying:
+		parent->mDuration = (float)(libvlc_media_get_duration(parent->mLibVLCMedia)) / 1000.0f;
+		parent->setStatus(STATUS_PLAYING);
+		break;
+
+	case libvlc_MediaPlayerPaused:
+		parent->setStatus(STATUS_PAUSED);
+		break;
+
+	case libvlc_MediaPlayerStopped:
+		parent->setStatus(STATUS_DONE);
+		break;
+
+	case libvlc_MediaPlayerEndReached:
+		parent->setStatus(STATUS_DONE);
+		break;
+
+	case libvlc_MediaPlayerEncounteredError:
+		parent->setStatus(STATUS_ERROR);
+		break;
+
+	case libvlc_MediaPlayerTimeChanged:
+		parent->mCurTime = (float)libvlc_media_player_get_time(parent->mLibVLCMediaPlayer) / 1000.0f;
+		break;
+
+	case libvlc_MediaPlayerPositionChanged:
+		break;
+
+	case libvlc_MediaPlayerLengthChanged:
+		parent->mDuration = (float)libvlc_media_get_duration(parent->mLibVLCMedia) / 1000.0f;
+		break;
+
+	case libvlc_MediaPlayerTitleChanged:
+	{
+		char* title = libvlc_media_get_meta(parent->mLibVLCMedia, libvlc_meta_Title);
+		if (title)
+		{
+			parent->updateTitle(title);
+		}
+	}
+	break;
+	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -168,30 +269,73 @@ void MediaPluginLibVLC::playMedia()
 		return;
 	}
 
-	if (gLibVLCMediaPlayer)
+	if (mLibVLCMediaPlayer)
+	{
+		// stop listening to events while we reset things
+		libvlc_event_manager_t* em = libvlc_media_player_event_manager(mLibVLCMediaPlayer);
+		if (em)
+		{
+			libvlc_event_detach(em, libvlc_MediaPlayerOpening, eventCallbacks, NULL);
+			libvlc_event_detach(em, libvlc_MediaPlayerBuffering, eventCallbacks, NULL);
+			libvlc_event_detach(em, libvlc_MediaPlayerPlaying, eventCallbacks, NULL);
+			libvlc_event_detach(em, libvlc_MediaPlayerPaused, eventCallbacks, NULL);
+			libvlc_event_detach(em, libvlc_MediaPlayerStopped, eventCallbacks, NULL);
+			libvlc_event_detach(em, libvlc_MediaPlayerEndReached, eventCallbacks, NULL);
+			libvlc_event_detach(em, libvlc_MediaPlayerEncounteredError, eventCallbacks, NULL);
+			libvlc_event_detach(em, libvlc_MediaPlayerTimeChanged, eventCallbacks, NULL);
+			libvlc_event_detach(em, libvlc_MediaPlayerPositionChanged, eventCallbacks, NULL);
+			libvlc_event_detach(em, libvlc_MediaPlayerLengthChanged, eventCallbacks, NULL);
+			libvlc_event_detach(em, libvlc_MediaPlayerTitleChanged, eventCallbacks, NULL);
+		};
+
+		libvlc_media_player_stop(mLibVLCMediaPlayer);
+		libvlc_media_player_release(mLibVLCMediaPlayer);
+
+		mLibVLCMediaPlayer = 0;
+	}
+
+	if (mLibVLCMedia)
 	{
-		libvlc_media_player_stop(gLibVLCMediaPlayer);
-		libvlc_media_player_release(gLibVLCMediaPlayer);
+		libvlc_media_release(mLibVLCMedia);
+
+		mLibVLCMedia = 0;
 	}
 
-	gLibVLCMedia = libvlc_media_new_location(gLibVLC, mURL.c_str());
-	if (!gLibVLCMedia)
+	mLibVLCMedia = libvlc_media_new_location(mLibVLC, mURL.c_str());
+	if (!mLibVLCMedia)
 	{
-		gLibVLCMediaPlayer = 0;
+		mLibVLCMediaPlayer = 0;
+		setStatus(STATUS_ERROR);
 		return;
 	}
 
-	gLibVLCMediaPlayer = libvlc_media_player_new_from_media(gLibVLCMedia);
-	if (!gLibVLCMediaPlayer)
+	mLibVLCMediaPlayer = libvlc_media_player_new_from_media(mLibVLCMedia);
+	if (!mLibVLCMediaPlayer)
 	{
+		setStatus(STATUS_ERROR);
 		return;
 	}
 
-	libvlc_media_release(gLibVLCMedia);
+	// listen to events
+	libvlc_event_manager_t* em = libvlc_media_player_event_manager(mLibVLCMediaPlayer);
+	if (em)
+	{
+		libvlc_event_attach(em, libvlc_MediaPlayerOpening, eventCallbacks, this);
+		libvlc_event_attach(em, libvlc_MediaPlayerBuffering, eventCallbacks, this);
+		libvlc_event_attach(em, libvlc_MediaPlayerPlaying, eventCallbacks, this);
+		libvlc_event_attach(em, libvlc_MediaPlayerPaused, eventCallbacks, this);
+		libvlc_event_attach(em, libvlc_MediaPlayerStopped, eventCallbacks, this);
+		libvlc_event_attach(em, libvlc_MediaPlayerEndReached, eventCallbacks, this);
+		libvlc_event_attach(em, libvlc_MediaPlayerEncounteredError, eventCallbacks, this);
+		libvlc_event_attach(em, libvlc_MediaPlayerTimeChanged, eventCallbacks, this);
+		libvlc_event_attach(em, libvlc_MediaPlayerPositionChanged, eventCallbacks, this);
+		libvlc_event_attach(em, libvlc_MediaPlayerLengthChanged, eventCallbacks, this);
+		libvlc_event_attach(em, libvlc_MediaPlayerTitleChanged, eventCallbacks, this);
+	}
 
-	gVLCCallbackContext.parent = this;
-	gVLCCallbackContext.texture_pixels = mPixels;
-	gVLCCallbackContext.mp = gLibVLCMediaPlayer;
+	mLibVLCCallbackContext.parent = this;
+	mLibVLCCallbackContext.texture_pixels = mPixels;
+	mLibVLCCallbackContext.mp = mLibVLCMediaPlayer;
 
 	// Send a "navigate begin" event.
 	// This is really a browser message but the QuickTime plugin did it and 
@@ -208,9 +352,24 @@ void MediaPluginLibVLC::playMedia()
 	// it in mCurVolume and set it again here so that volume levels are correctly initialized
 	setVolume(mCurVolume);
 
-	libvlc_video_set_callbacks(gLibVLCMediaPlayer, lock, unlock, display, &gVLCCallbackContext);
-	libvlc_video_set_format(gLibVLCMediaPlayer, "RV32", mWidth, mHeight, mWidth * mDepth);
-	libvlc_media_player_play(gLibVLCMediaPlayer);
+	setStatus(STATUS_LOADED);
+
+	libvlc_video_set_callbacks(mLibVLCMediaPlayer, lock, unlock, display, &mLibVLCCallbackContext);
+	libvlc_video_set_format(mLibVLCMediaPlayer, "RV32", mWidth, mHeight, mWidth * mDepth);
+
+	if (mIsLooping)
+	{
+		libvlc_media_add_option(mLibVLCMedia, "input-repeat=-1");
+	}
+
+	libvlc_media_player_play(mLibVLCMediaPlayer);
+
+	// send a "location_changed" message - this informs the media system
+	// that a new URL is the 'current' one and is used extensively.
+	// Again, this is really a browser message but we will use it here.
+	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA_BROWSER, "location_changed");
+	message.setValue("uri", mURL);
+	sendMessage(message);
 
 	// Send a "navigate complete" event.
 	// This is really a browser message but the QuickTime plugin did it and 
@@ -226,13 +385,22 @@ void MediaPluginLibVLC::playMedia()
 
 ////////////////////////////////////////////////////////////////////////////////
 //
+void MediaPluginLibVLC::updateTitle(const char* title)
+{
+	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text");
+	message.setValue("name", title);
+	sendMessage(message);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
 void MediaPluginLibVLC::setVolume(const F64 volume)
 {
 	mCurVolume = volume;
 
-	if (gLibVLCMediaPlayer)
+	if (mLibVLCMediaPlayer)
 	{
-		int result = libvlc_audio_set_volume(gLibVLCMediaPlayer, (int)(volume * 100));
+		int result = libvlc_audio_set_volume(mLibVLCMediaPlayer, (int)(volume * 100));
 		if (result != 0)
 		{
 			// volume wasn't set but not much to be done here
@@ -248,26 +416,26 @@ void MediaPluginLibVLC::setVolume(const F64 volume)
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-void MediaPluginLibVLC::receiveMessage( const char* message_string )
+void MediaPluginLibVLC::receiveMessage(const char* message_string)
 {
-    LLPluginMessage message_in;
-
-    if(message_in.parse(message_string) >= 0)
-    {
-        std::string message_class = message_in.getClass();
-        std::string message_name = message_in.getName();
-        if(message_class == LLPLUGIN_MESSAGE_CLASS_BASE)
-        {
-            if(message_name == "init")
-            {
+	LLPluginMessage message_in;
+
+	if (message_in.parse(message_string) >= 0)
+	{
+		std::string message_class = message_in.getClass();
+		std::string message_name = message_in.getName();
+		if (message_class == LLPLUGIN_MESSAGE_CLASS_BASE)
+		{
+			if (message_name == "init")
+			{
 				initVLC();
 
-                LLPluginMessage message("base", "init_response");
-                LLSD versions = LLSD::emptyMap();
-                versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
-                versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
+				LLPluginMessage message("base", "init_response");
+				LLSD versions = LLSD::emptyMap();
+				versions[LLPLUGIN_MESSAGE_CLASS_BASE] = LLPLUGIN_MESSAGE_CLASS_BASE_VERSION;
+				versions[LLPLUGIN_MESSAGE_CLASS_MEDIA] = LLPLUGIN_MESSAGE_CLASS_MEDIA_VERSION;
 				versions[LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME] = LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME_VERSION;
-                message.setValueLLSD("versions", versions);
+				message.setValueLLSD("versions", versions);
 
 				std::ostringstream s;
 				s << "LibVLC plugin ";
@@ -277,96 +445,96 @@ void MediaPluginLibVLC::receiveMessage( const char* message_string )
 				s << ".";
 				s << LIBVLC_VERSION_REVISION;
 
-                message.setValue("plugin_version", s.str());
-                sendMessage(message);
-            }
-            else if(message_name == "idle")
-            {
-            }
-            else if(message_name == "cleanup")
-            {
+				message.setValue("plugin_version", s.str());
+				sendMessage(message);
+			}
+			else if (message_name == "idle")
+			{
+			}
+			else if (message_name == "cleanup")
+			{
 				resetVLC();
-            }
-            else if(message_name == "shm_added")
-            {
-                SharedSegmentInfo info;
-                info.mAddress = message_in.getValuePointer("address");
-                info.mSize = (size_t)message_in.getValueS32("size");
-                std::string name = message_in.getValue("name");
-
-                mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
-
-            }
-            else if(message_name == "shm_remove")
-            {
-                std::string name = message_in.getValue("name");
-
-                SharedSegmentMap::iterator iter = mSharedSegments.find(name);
-                if(iter != mSharedSegments.end())
-                {
-                    if(mPixels == iter->second.mAddress)
-                    {
-						libvlc_media_player_stop(gLibVLCMediaPlayer);
-						libvlc_media_player_release(gLibVLCMediaPlayer);
-						gLibVLCMediaPlayer = 0;
-
-                        mPixels = NULL;
-                        mTextureSegmentName.clear();
-                    }
-                    mSharedSegments.erase(iter);
-                }
-                else
-                {
+			}
+			else if (message_name == "shm_added")
+			{
+				SharedSegmentInfo info;
+				info.mAddress = message_in.getValuePointer("address");
+				info.mSize = (size_t)message_in.getValueS32("size");
+				std::string name = message_in.getValue("name");
+
+				mSharedSegments.insert(SharedSegmentMap::value_type(name, info));
+
+			}
+			else if (message_name == "shm_remove")
+			{
+				std::string name = message_in.getValue("name");
+
+				SharedSegmentMap::iterator iter = mSharedSegments.find(name);
+				if (iter != mSharedSegments.end())
+				{
+					if (mPixels == iter->second.mAddress)
+					{
+						libvlc_media_player_stop(mLibVLCMediaPlayer);
+						libvlc_media_player_release(mLibVLCMediaPlayer);
+						mLibVLCMediaPlayer = 0;
+
+						mPixels = NULL;
+						mTextureSegmentName.clear();
+					}
+					mSharedSegments.erase(iter);
+				}
+				else
+				{
 					//std::cerr << "MediaPluginWebKit::receiveMessage: unknown shared memory region!" << std::endl;
-                }
-
-                // Send the response so it can be cleaned up.
-                LLPluginMessage message("base", "shm_remove_response");
-                message.setValue("name", name);
-                sendMessage(message);
-            }
-            else
-            {
+				}
+
+				// Send the response so it can be cleaned up.
+				LLPluginMessage message("base", "shm_remove_response");
+				message.setValue("name", name);
+				sendMessage(message);
+			}
+			else
+			{
 				//std::cerr << "MediaPluginWebKit::receiveMessage: unknown base message: " << message_name << std::endl;
-            }
-        }
-        else if(message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
-        {
-            if(message_name == "init")
-            {
-                LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
-                message.setValueS32("default_width", 1024);
-                message.setValueS32("default_height", 1024);
-                message.setValueS32("depth", mDepth);
+			}
+		}
+		else if (message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA)
+		{
+			if (message_name == "init")
+			{
+				LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "texture_params");
+				message.setValueS32("default_width", 1024);
+				message.setValueS32("default_height", 1024);
+				message.setValueS32("depth", mDepth);
 				message.setValueU32("internalformat", GL_RGB);
-                message.setValueU32("format", GL_BGRA_EXT);
-                message.setValueU32("type", GL_UNSIGNED_BYTE);
-                message.setValueBoolean("coords_opengl", false);
-                sendMessage(message);
-            }
-            else if(message_name == "size_change")
-            {
-                std::string name = message_in.getValue("name");
-                S32 width = message_in.getValueS32("width");
-                S32 height = message_in.getValueS32("height");
-                S32 texture_width = message_in.getValueS32("texture_width");
-                S32 texture_height = message_in.getValueS32("texture_height");
-
-                if(!name.empty())
-                {
-                    // Find the shared memory region with this name
-                    SharedSegmentMap::iterator iter = mSharedSegments.find(name);
-                    if(iter != mSharedSegments.end())
-                    {
-                        mPixels = (unsigned char*)iter->second.mAddress;
-                        mWidth = width;
-                        mHeight = height;
-                        mTextureWidth = texture_width;
-                        mTextureHeight = texture_height;
+				message.setValueU32("format", GL_BGRA_EXT);
+				message.setValueU32("type", GL_UNSIGNED_BYTE);
+				message.setValueBoolean("coords_opengl", true);
+				sendMessage(message);
+			}
+			else if (message_name == "size_change")
+			{
+				std::string name = message_in.getValue("name");
+				S32 width = message_in.getValueS32("width");
+				S32 height = message_in.getValueS32("height");
+				S32 texture_width = message_in.getValueS32("texture_width");
+				S32 texture_height = message_in.getValueS32("texture_height");
+
+				if (!name.empty())
+				{
+					// Find the shared memory region with this name
+					SharedSegmentMap::iterator iter = mSharedSegments.find(name);
+					if (iter != mSharedSegments.end())
+					{
+						mPixels = (unsigned char*)iter->second.mAddress;
+						mWidth = width;
+						mHeight = height;
+						mTextureWidth = texture_width;
+						mTextureHeight = texture_height;
 
 						playMedia();
 					};
-                };
+				};
 
 				LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "size_change_response");
 				message.setValue("name", name);
@@ -375,74 +543,75 @@ void MediaPluginLibVLC::receiveMessage( const char* message_string )
 				message.setValueS32("texture_width", texture_width);
 				message.setValueS32("texture_height", texture_height);
 				sendMessage(message);
-            }
-            else if(message_name == "load_uri")
-            {
+			}
+			else if (message_name == "load_uri")
+			{
 				mURL = message_in.getValue("uri");
 				playMedia();
-            }
-        }
-		else 
-		if (message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
-		{
-			if (message_name == "stop")
+			}
+		}
+		else
+			if (message_class == LLPLUGIN_MESSAGE_CLASS_MEDIA_TIME)
 			{
-				if (gLibVLCMediaPlayer)
+				if (message_name == "stop")
 				{
-					libvlc_media_player_stop(gLibVLCMediaPlayer);
+					if (mLibVLCMediaPlayer)
+					{
+						libvlc_media_player_stop(mLibVLCMediaPlayer);
+					}
 				}
-			}
-			else if (message_name == "start")
-			{
-				if (gLibVLCMediaPlayer)
+				else if (message_name == "start")
 				{
-					libvlc_media_player_play(gLibVLCMediaPlayer);
+					if (mLibVLCMediaPlayer)
+					{
+						libvlc_media_player_play(mLibVLCMediaPlayer);
+					}
 				}
-			}
-			else if (message_name == "pause")
-			{
-				if (gLibVLCMediaPlayer)
+				else if (message_name == "pause")
 				{
-					libvlc_media_player_pause(gLibVLCMediaPlayer);
+					if (mLibVLCMediaPlayer)
+					{
+						libvlc_media_player_pause(mLibVLCMediaPlayer);
+					}
+				}
+				else if (message_name == "seek")
+				{
+				}
+				else if (message_name == "set_loop")
+				{
+					mIsLooping = true;
+				}
+				else if (message_name == "set_volume")
+				{
+					// volume comes in 0 -> 1.0
+					F64 volume = message_in.getValueReal("volume");
+					setVolume(volume);
 				}
 			}
-			else if (message_name == "seek")
-			{
-			}
-			else if (message_name == "set_loop")
-			{
-			}
-			else if (message_name == "set_volume")
-			{
-				// volume comes in 0 -> 1.0
-				F64 volume = message_in.getValueReal("volume");
-				setVolume(volume);
-			}
-		}
-    }
+	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 bool MediaPluginLibVLC::init()
 {
-    LLPluginMessage message( LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text" );
-    message.setValue( "name", "LibVLC Plugin" );
-    sendMessage( message );
+	LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_MEDIA, "name_text");
+	message.setValue("name", "LibVLC Plugin");
+	sendMessage(message);
 
-    return true;
+	return true;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 //
-int init_media_plugin( LLPluginInstance::sendMessageFunction host_send_func,
-                        void* host_user_data,
-                        LLPluginInstance::sendMessageFunction *plugin_send_func,
-                        void **plugin_user_data )
+int init_media_plugin(LLPluginInstance::sendMessageFunction host_send_func,
+	void* host_user_data,
+	LLPluginInstance::sendMessageFunction *plugin_send_func,
+	void **plugin_user_data)
 {
-    MediaPluginLibVLC* self = new MediaPluginLibVLC( host_send_func, host_user_data );
-    *plugin_send_func = MediaPluginLibVLC::staticReceiveMessage;
-    *plugin_user_data = ( void* )self;
+	MediaPluginLibVLC* self = new MediaPluginLibVLC(host_send_func, host_user_data);
+	*plugin_send_func = MediaPluginLibVLC::staticReceiveMessage;
+	*plugin_user_data = (void*)self;
 
-    return 0;
+	return 0;
 }